lldb/source/Commands/CommandObjectExpression.cpp

   1 //===-- CommandObjectExpression.cpp -----------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ADT/StringRef.h"
  10
  11 #include "CommandObjectExpression.h"
  12 #include "lldb/Core/Debugger.h"
  13 #include "lldb/Expression/REPL.h"
  14 #include "lldb/Expression/UserExpression.h"
  15 #include "lldb/Host/OptionParser.h"
  16 #include "lldb/Interpreter/CommandInterpreter.h"
  17 #include "lldb/Interpreter/CommandReturnObject.h"
  18 #include "lldb/Interpreter/OptionArgParser.h"
  19 #include "lldb/Target/Language.h"
  20 #include "lldb/Target/Process.h"
  21 #include "lldb/Target/StackFrame.h"
  22 #include "lldb/Target/Target.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 CommandObjectExpression::CommandOptions::CommandOptions() : OptionGroup() {}
  28
  29 CommandObjectExpression::CommandOptions::~CommandOptions() = default;
  30
  31 static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
  32     {
  33         eLanguageRuntimeDescriptionDisplayVerbosityCompact,
  34         "compact",
  35         "Only show the description string",
  36     },
  37     {
  38         eLanguageRuntimeDescriptionDisplayVerbosityFull,
  39         "full",
  40         "Show the full output, including persistent variable's name and type",
  41     },
  42 };
  43
  44 static constexpr OptionEnumValues DescriptionVerbosityTypes() {
  45   return OptionEnumValues(g_description_verbosity_type);
  46 }
  47
  48 #define LLDB_OPTIONS_expression
  49 #include "CommandOptions.inc"
  50
  51 Status CommandObjectExpression::CommandOptions::SetOptionValue(
  52     uint32_t option_idx, llvm::StringRef option_arg,
  53     ExecutionContext *execution_context) {
  54   Status error;
  55
  56   const int short_option = GetDefinitions()[option_idx].short_option;
  57
  58   switch (short_option) {
  59   case 'l':
  60     language = Language::GetLanguageTypeFromString(option_arg);
  61     if (language == eLanguageTypeUnknown)
  62       error.SetErrorStringWithFormat(
  63           "unknown language type: '%s' for expression",
  64           option_arg.str().c_str());
  65     break;
  66
  67   case 'a': {
  68     bool success;
  69     bool result;
  70     result = OptionArgParser::ToBoolean(option_arg, true, &success);
  71     if (!success)
  72       error.SetErrorStringWithFormat(
  73           "invalid all-threads value setting: \"%s\"",
  74           option_arg.str().c_str());
  75     else
  76       try_all_threads = result;
  77   } break;
  78
  79   case 'i': {
  80     bool success;
  81     bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
  82     if (success)
  83       ignore_breakpoints = tmp_value;
  84     else
  85       error.SetErrorStringWithFormat(
  86           "could not convert \"%s\" to a boolean value.",
  87           option_arg.str().c_str());
  88     break;
  89   }
  90
  91   case 'j': {
  92     bool success;
  93     bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
  94     if (success)
  95       allow_jit = tmp_value;
  96     else
  97       error.SetErrorStringWithFormat(
  98           "could not convert \"%s\" to a boolean value.",
  99           option_arg.str().c_str());
 100     break;
 101   }
 102
 103   case 't':
 104     if (option_arg.getAsInteger(0, timeout)) {
 105       timeout = 0;
 106       error.SetErrorStringWithFormat("invalid timeout setting \"%s\"",
 107                                      option_arg.str().c_str());
 108     }
 109     break;
 110
 111   case 'u': {
 112     bool success;
 113     bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
 114     if (success)
 115       unwind_on_error = tmp_value;
 116     else
 117       error.SetErrorStringWithFormat(
 118           "could not convert \"%s\" to a boolean value.",
 119           option_arg.str().c_str());
 120     break;
 121   }
 122
 123   case 'v':
 124     if (option_arg.empty()) {
 125       m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull;
 126       break;
 127     }
 128     m_verbosity = (LanguageRuntimeDescriptionDisplayVerbosity)
 129         OptionArgParser::ToOptionEnum(
 130             option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
 131     if (!error.Success())
 132       error.SetErrorStringWithFormat(
 133           "unrecognized value for description-verbosity '%s'",
 134           option_arg.str().c_str());
 135     break;
 136
 137   case 'g':
 138     debug = true;
 139     unwind_on_error = false;
 140     ignore_breakpoints = false;
 141     break;
 142
 143   case 'p':
 144     top_level = true;
 145     break;
 146
 147   case 'X': {
 148     bool success;
 149     bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success);
 150     if (success)
 151       auto_apply_fixits = tmp_value ? eLazyBoolYes : eLazyBoolNo;
 152     else
 153       error.SetErrorStringWithFormat(
 154           "could not convert \"%s\" to a boolean value.",
 155           option_arg.str().c_str());
 156     break;
 157   }
 158
 159   default:
 160     llvm_unreachable("Unimplemented option");
 161   }
 162
 163   return error;
 164 }
 165
 166 void CommandObjectExpression::CommandOptions::OptionParsingStarting(
 167     ExecutionContext *execution_context) {
 168   auto process_sp =
 169       execution_context ? execution_context->GetProcessSP() : ProcessSP();
 170   if (process_sp) {
 171     ignore_breakpoints = process_sp->GetIgnoreBreakpointsInExpressions();
 172     unwind_on_error = process_sp->GetUnwindOnErrorInExpressions();
 173   } else {
 174     ignore_breakpoints = true;
 175     unwind_on_error = true;
 176   }
 177
 178   show_summary = true;
 179   try_all_threads = true;
 180   timeout = 0;
 181   debug = false;
 182   language = eLanguageTypeUnknown;
 183   m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
 184   auto_apply_fixits = eLazyBoolCalculate;
 185   top_level = false;
 186   allow_jit = true;
 187 }
 188
 189 llvm::ArrayRef<OptionDefinition>
 190 CommandObjectExpression::CommandOptions::GetDefinitions() {
 191   return llvm::makeArrayRef(g_expression_options);
 192 }
 193
 194 CommandObjectExpression::CommandObjectExpression(
 195     CommandInterpreter &interpreter)
 196     : CommandObjectRaw(interpreter, "expression",
 197                        "Evaluate an expression on the current "
 198                        "thread.  Displays any returned value "
 199                        "with LLDB's default formatting.",
 200                        "",
 201                        eCommandProcessMustBePaused | eCommandTryTargetAPILock),
 202       IOHandlerDelegate(IOHandlerDelegate::Completion::Expression),
 203       m_option_group(), m_format_options(eFormatDefault),
 204       m_repl_option(LLDB_OPT_SET_1, false, "repl", 'r', "Drop into REPL", false,
 205                     true),
 206       m_command_options(), m_expr_line_count(0), m_expr_lines() {
 207   SetHelpLong(
 208       R"(
 209 Single and multi-line expressions:
 210
 211 )"
 212       "    The expression provided on the command line must be a complete expression \
 213 with no newlines.  To evaluate a multi-line expression, \
 214 hit a return after an empty expression, and lldb will enter the multi-line expression editor. \
 215 Hit return on an empty line to end the multi-line expression."
 216
 217       R"(
 218
 219 Timeouts:
 220
 221 )"
 222       "    If the expression can be evaluated statically (without running code) then it will be.  \
 223 Otherwise, by default the expression will run on the current thread with a short timeout: \
 224 currently .25 seconds.  If it doesn't return in that time, the evaluation will be interrupted \
 225 and resumed with all threads running.  You can use the -a option to disable retrying on all \
 226 threads.  You can use the -t option to set a shorter timeout."
 227       R"(
 228
 229 User defined variables:
 230
 231 )"
 232       "    You can define your own variables for convenience or to be used in subsequent expressions.  \
 233 You define them the same way you would define variables in C.  If the first character of \
 234 your user defined variable is a $, then the variable's value will be available in future \
 235 expressions, otherwise it will just be available in the current expression."
 236       R"(
 237
 238 Continuing evaluation after a breakpoint:
 239
 240 )"
 241       "    If the \"-i false\" option is used, and execution is interrupted by a breakpoint hit, once \
 242 you are done with your investigation, you can either remove the expression execution frames \
 243 from the stack with \"thread return -x\" or if you are still interested in the expression result \
 244 you can issue the \"continue\" command and the expression evaluation will complete and the \
 245 expression result will be available using the \"thread.completed-expression\" key in the thread \
 246 format."
 247
 248       R"(
 249
 250 Examples:
 251
 252     expr my_struct->a = my_array[3]
 253     expr -f bin -- (index * 8) + 5
 254     expr unsigned int $foo = 5
 255     expr char c[] = \"foo\"; c[0])");
 256
 257   CommandArgumentEntry arg;
 258   CommandArgumentData expression_arg;
 259
 260   // Define the first (and only) variant of this arg.
 261   expression_arg.arg_type = eArgTypeExpression;
 262   expression_arg.arg_repetition = eArgRepeatPlain;
 263
 264   // There is only one variant this argument could be; put it into the argument
 265   // entry.
 266   arg.push_back(expression_arg);
 267
 268   // Push the data for the first argument into the m_arguments vector.
 269   m_arguments.push_back(arg);
 270
 271   // Add the "--format" and "--gdb-format"
 272   m_option_group.Append(&m_format_options,
 273                         OptionGroupFormat::OPTION_GROUP_FORMAT |
 274                             OptionGroupFormat::OPTION_GROUP_GDB_FMT,
 275                         LLDB_OPT_SET_1);
 276   m_option_group.Append(&m_command_options);
 277   m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL,
 278                         LLDB_OPT_SET_1 | LLDB_OPT_SET_2);
 279   m_option_group.Append(&m_repl_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3);
 280   m_option_group.Finalize();
 281 }
 282
 283 CommandObjectExpression::~CommandObjectExpression() = default;
 284
 285 Options *CommandObjectExpression::GetOptions() { return &m_option_group; }
 286
 287 void CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
 288   EvaluateExpressionOptions options;
 289   options.SetCoerceToId(m_varobj_options.use_objc);
 290   options.SetLanguage(m_command_options.language);
 291   options.SetExecutionPolicy(lldb_private::eExecutionPolicyNever);
 292   options.SetAutoApplyFixIts(false);
 293   options.SetGenerateDebugInfo(false);
 294
 295   // We need a valid execution context with a frame pointer for this
 296   // completion, so if we don't have one we should try to make a valid
 297   // execution context.
 298   if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
 299     m_interpreter.UpdateExecutionContext(nullptr);
 300
 301   // This didn't work, so let's get out before we start doing things that
 302   // expect a valid frame pointer.
 303   if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
 304     return;
 305
 306   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 307
 308   Target *target = exe_ctx.GetTargetPtr();
 309
 310   if (!target)
 311     target = &GetDummyTarget();
 312
 313   unsigned cursor_pos = request.GetRawCursorPos();
 314   llvm::StringRef code = request.GetRawLine();
 315
 316   const std::size_t original_code_size = code.size();
 317
 318   // Remove the first token which is 'expr' or some alias/abbreviation of that.
 319   code = llvm::getToken(code).second.ltrim();
 320   OptionsWithRaw args(code);
 321   code = args.GetRawPart();
 322
 323   // The position where the expression starts in the command line.
 324   assert(original_code_size >= code.size());
 325   std::size_t raw_start = original_code_size - code.size();
 326
 327   // Check if the cursor is actually in the expression string, and if not, we
 328   // exit.
 329   // FIXME: We should complete the options here.
 330   if (cursor_pos < raw_start)
 331     return;
 332
 333   // Make the cursor_pos again relative to the start of the code string.
 334   assert(cursor_pos >= raw_start);
 335   cursor_pos -= raw_start;
 336
 337   auto language = exe_ctx.GetFrameRef().GetLanguage();
 338
 339   Status error;
 340   lldb::UserExpressionSP expr(target->GetUserExpressionForLanguage(
 341       code, llvm::StringRef(), language, UserExpression::eResultTypeAny,
 342       options, nullptr, error));
 343   if (error.Fail())
 344     return;
 345
 346   expr->Complete(exe_ctx, request, cursor_pos);
 347 }
 348
 349 static lldb_private::Status
 350 CanBeUsedForElementCountPrinting(ValueObject &valobj) {
 351   CompilerType type(valobj.GetCompilerType());
 352   CompilerType pointee;
 353   if (!type.IsPointerType(&pointee))
 354     return Status("as it does not refer to a pointer");
 355   if (pointee.IsVoidType())
 356     return Status("as it refers to a pointer to void");
 357   return Status();
 358 }
 359
 360 bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr,
 361                                                  Stream *output_stream,
 362                                                  Stream *error_stream,
 363                                                  CommandReturnObject *result) {
 364   // Don't use m_exe_ctx as this might be called asynchronously after the
 365   // command object DoExecute has finished when doing multi-line expression
 366   // that use an input reader...
 367   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 368
 369   Target *target = exe_ctx.GetTargetPtr();
 370
 371   if (!target)
 372     target = &GetDummyTarget();
 373
 374   lldb::ValueObjectSP result_valobj_sp;
 375   bool keep_in_memory = true;
 376   StackFrame *frame = exe_ctx.GetFramePtr();
 377
 378   EvaluateExpressionOptions options;
 379   options.SetCoerceToId(m_varobj_options.use_objc);
 380   options.SetUnwindOnError(m_command_options.unwind_on_error);
 381   options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints);
 382   options.SetKeepInMemory(keep_in_memory);
 383   options.SetUseDynamic(m_varobj_options.use_dynamic);
 384   options.SetTryAllThreads(m_command_options.try_all_threads);
 385   options.SetDebug(m_command_options.debug);
 386   options.SetLanguage(m_command_options.language);
 387   options.SetExecutionPolicy(
 388       m_command_options.allow_jit
 389           ? EvaluateExpressionOptions::default_execution_policy
 390           : lldb_private::eExecutionPolicyNever);
 391
 392   bool auto_apply_fixits;
 393   if (m_command_options.auto_apply_fixits == eLazyBoolCalculate)
 394     auto_apply_fixits = target->GetEnableAutoApplyFixIts();
 395   else
 396     auto_apply_fixits = m_command_options.auto_apply_fixits == eLazyBoolYes;
 397
 398   options.SetAutoApplyFixIts(auto_apply_fixits);
 399
 400   if (m_command_options.top_level)
 401     options.SetExecutionPolicy(eExecutionPolicyTopLevel);
 402
 403   // If there is any chance we are going to stop and want to see what went
 404   // wrong with our expression, we should generate debug info
 405   if (!m_command_options.ignore_breakpoints ||
 406       !m_command_options.unwind_on_error)
 407     options.SetGenerateDebugInfo(true);
 408
 409   if (m_command_options.timeout > 0)
 410     options.SetTimeout(std::chrono::microseconds(m_command_options.timeout));
 411   else
 412     options.SetTimeout(llvm::None);
 413
 414   ExpressionResults success = target->EvaluateExpression(
 415       expr, frame, result_valobj_sp, options, &m_fixed_expression);
 416
 417   // We only tell you about the FixIt if we applied it.  The compiler errors
 418   // will suggest the FixIt if it parsed.
 419   if (error_stream && !m_fixed_expression.empty() &&
 420       target->GetEnableNotifyAboutFixIts()) {
 421     if (success == eExpressionCompleted)
 422       error_stream->Printf("  Fix-it applied, fixed expression was: \n    %s\n",
 423                            m_fixed_expression.c_str());
 424   }
 425
 426   if (result_valobj_sp) {
 427     Format format = m_format_options.GetFormat();
 428
 429     if (result_valobj_sp->GetError().Success()) {
 430       if (format != eFormatVoid) {
 431         if (format != eFormatDefault)
 432           result_valobj_sp->SetFormat(format);
 433
 434         if (m_varobj_options.elem_count > 0) {
 435           Status error(CanBeUsedForElementCountPrinting(*result_valobj_sp));
 436           if (error.Fail()) {
 437             result->AppendErrorWithFormat(
 438                 "expression cannot be used with --element-count %s\n",
 439                 error.AsCString(""));
 440             result->SetStatus(eReturnStatusFailed);
 441             return false;
 442           }
 443         }
 444
 445         DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(
 446             m_command_options.m_verbosity, format));
 447         options.SetVariableFormatDisplayLanguage(
 448             result_valobj_sp->GetPreferredDisplayLanguage());
 449
 450         result_valobj_sp->Dump(*output_stream, options);
 451
 452         if (result)
 453           result->SetStatus(eReturnStatusSuccessFinishResult);
 454       }
 455     } else {
 456       if (result_valobj_sp->GetError().GetError() ==
 457           UserExpression::kNoResult) {
 458         if (format != eFormatVoid && GetDebugger().GetNotifyVoid()) {
 459           error_stream->PutCString("(void)\n");
 460         }
 461
 462         if (result)
 463           result->SetStatus(eReturnStatusSuccessFinishResult);
 464       } else {
 465         const char *error_cstr = result_valobj_sp->GetError().AsCString();
 466         if (error_cstr && error_cstr[0]) {
 467           const size_t error_cstr_len = strlen(error_cstr);
 468           const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n';
 469           if (strstr(error_cstr, "error:") != error_cstr)
 470             error_stream->PutCString("error: ");
 471           error_stream->Write(error_cstr, error_cstr_len);
 472           if (!ends_with_newline)
 473             error_stream->EOL();
 474         } else {
 475           error_stream->PutCString("error: unknown error\n");
 476         }
 477
 478         if (result)
 479           result->SetStatus(eReturnStatusFailed);
 480       }
 481     }
 482   }
 483
 484   return true;
 485 }
 486
 487 void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler,
 488                                                      std::string &line) {
 489   io_handler.SetIsDone(true);
 490   //    StreamSP output_stream =
 491   //    io_handler.GetDebugger().GetAsyncOutputStream();
 492   //    StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream();
 493   StreamFileSP output_sp = io_handler.GetOutputStreamFileSP();
 494   StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
 495
 496   EvaluateExpression(line.c_str(), output_sp.get(), error_sp.get());
 497   if (output_sp)
 498     output_sp->Flush();
 499   if (error_sp)
 500     error_sp->Flush();
 501 }
 502
 503 bool CommandObjectExpression::IOHandlerIsInputComplete(IOHandler &io_handler,
 504                                                        StringList &lines) {
 505   // An empty lines is used to indicate the end of input
 506   const size_t num_lines = lines.GetSize();
 507   if (num_lines > 0 && lines[num_lines - 1].empty()) {
 508     // Remove the last empty line from "lines" so it doesn't appear in our
 509     // resulting input and return true to indicate we are done getting lines
 510     lines.PopBack();
 511     return true;
 512   }
 513   return false;
 514 }
 515
 516 void CommandObjectExpression::GetMultilineExpression() {
 517   m_expr_lines.clear();
 518   m_expr_line_count = 0;
 519
 520   Debugger &debugger = GetCommandInterpreter().GetDebugger();
 521   bool color_prompt = debugger.GetUseColor();
 522   const bool multiple_lines = true; // Get multiple lines
 523   IOHandlerSP io_handler_sp(
 524       new IOHandlerEditline(debugger, IOHandler::Type::Expression,
 525                             "lldb-expr", // Name of input reader for history
 526                             llvm::StringRef(), // No prompt
 527                             llvm::StringRef(), // Continuation prompt
 528                             multiple_lines, color_prompt,
 529                             1, // Show line numbers starting at 1
 530                             *this, nullptr));
 531
 532   StreamFileSP output_sp = io_handler_sp->GetOutputStreamFileSP();
 533   if (output_sp) {
 534     output_sp->PutCString(
 535         "Enter expressions, then terminate with an empty line to evaluate:\n");
 536     output_sp->Flush();
 537   }
 538   debugger.RunIOHandlerAsync(io_handler_sp);
 539 }
 540
 541 static EvaluateExpressionOptions
 542 GetExprOptions(ExecutionContext &ctx,
 543                CommandObjectExpression::CommandOptions command_options) {
 544   command_options.OptionParsingStarting(&ctx);
 545
 546   // Default certain settings for REPL regardless of the global settings.
 547   command_options.unwind_on_error = false;
 548   command_options.ignore_breakpoints = false;
 549   command_options.debug = false;
 550
 551   EvaluateExpressionOptions expr_options;
 552   expr_options.SetUnwindOnError(command_options.unwind_on_error);
 553   expr_options.SetIgnoreBreakpoints(command_options.ignore_breakpoints);
 554   expr_options.SetTryAllThreads(command_options.try_all_threads);
 555
 556   if (command_options.timeout > 0)
 557     expr_options.SetTimeout(std::chrono::microseconds(command_options.timeout));
 558   else
 559     expr_options.SetTimeout(llvm::None);
 560
 561   return expr_options;
 562 }
 563
 564 bool CommandObjectExpression::DoExecute(llvm::StringRef command,
 565                                         CommandReturnObject &result) {
 566   m_fixed_expression.clear();
 567   auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
 568   m_option_group.NotifyOptionParsingStarting(&exe_ctx);
 569
 570   if (command.empty()) {
 571     GetMultilineExpression();
 572     return result.Succeeded();
 573   }
 574
 575   OptionsWithRaw args(command);
 576   llvm::StringRef expr = args.GetRawPart();
 577
 578   if (args.HasArgs()) {
 579     if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, exe_ctx))
 580       return false;
 581
 582     if (m_repl_option.GetOptionValue().GetCurrentValue()) {
 583       Target &target = GetSelectedOrDummyTarget();
 584       // Drop into REPL
 585       m_expr_lines.clear();
 586       m_expr_line_count = 0;
 587
 588       Debugger &debugger = target.GetDebugger();
 589
 590       // Check if the LLDB command interpreter is sitting on top of a REPL
 591       // that launched it...
 592       if (debugger.CheckTopIOHandlerTypes(IOHandler::Type::CommandInterpreter,
 593                                           IOHandler::Type::REPL)) {
 594         // the LLDB command interpreter is sitting on top of a REPL that
 595         // launched it, so just say the command interpreter is done and
 596         // fall back to the existing REPL
 597         m_interpreter.GetIOHandler(false)->SetIsDone(true);
 598       } else {
 599         // We are launching the REPL on top of the current LLDB command
 600         // interpreter, so just push one
 601         bool initialize = false;
 602         Status repl_error;
 603         REPLSP repl_sp(target.GetREPL(repl_error, m_command_options.language,
 604                                        nullptr, false));
 605
 606         if (!repl_sp) {
 607           initialize = true;
 608           repl_sp = target.GetREPL(repl_error, m_command_options.language,
 609                                     nullptr, true);
 610           if (!repl_error.Success()) {
 611             result.SetError(repl_error);
 612             return result.Succeeded();
 613           }
 614         }
 615
 616         if (repl_sp) {
 617           if (initialize) {
 618             repl_sp->SetEvaluateOptions(
 619                 GetExprOptions(exe_ctx, m_command_options));
 620             repl_sp->SetFormatOptions(m_format_options);
 621             repl_sp->SetValueObjectDisplayOptions(m_varobj_options);
 622           }
 623
 624           IOHandlerSP io_handler_sp(repl_sp->GetIOHandler());
 625           io_handler_sp->SetIsDone(false);
 626           debugger.RunIOHandlerAsync(io_handler_sp);
 627         } else {
 628           repl_error.SetErrorStringWithFormat(
 629               "Couldn't create a REPL for %s",
 630               Language::GetNameForLanguageType(m_command_options.language));
 631           result.SetError(repl_error);
 632           return result.Succeeded();
 633         }
 634       }
 635     }
 636     // No expression following options
 637     else if (expr.empty()) {
 638       GetMultilineExpression();
 639       return result.Succeeded();
 640     }
 641   }
 642
 643   Target &target = GetSelectedOrDummyTarget();
 644   if (EvaluateExpression(expr, &(result.GetOutputStream()),
 645                          &(result.GetErrorStream()), &result)) {
 646
 647     if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
 648       CommandHistory &history = m_interpreter.GetCommandHistory();
 649       // FIXME: Can we figure out what the user actually typed (e.g. some alias
 650       // for expr???)
 651       // If we can it would be nice to show that.
 652       std::string fixed_command("expression ");
 653       if (args.HasArgs()) {
 654         // Add in any options that might have been in the original command:
 655         fixed_command.append(args.GetArgStringWithDelimiter());
 656         fixed_command.append(m_fixed_expression);
 657       } else
 658         fixed_command.append(m_fixed_expression);
 659       history.AppendString(fixed_command);
 660     }
 661     // Increment statistics to record this expression evaluation success.
 662     target.IncrementStats(StatisticKind::ExpressionSuccessful);
 663     return true;
 664   }
 665
 666   // Increment statistics to record this expression evaluation failure.
 667   target.IncrementStats(StatisticKind::ExpressionFailure);
 668   result.SetStatus(eReturnStatusFailed);
 669   return false;
 670 }