LLDB  mainline
CommandObjectExpression.cpp
Go to the documentation of this file.
1 //===-- CommandObjectExpression.cpp ---------------------------------------===//
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 
12 #include "lldb/Core/Debugger.h"
13 #include "lldb/Expression/REPL.h"
15 #include "lldb/Host/OptionParser.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 
30 
31 static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
32  {
34  "compact",
35  "Only show the description string",
36  },
37  {
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 
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()) {
126  break;
127  }
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 
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;
184  auto_apply_fixits = eLazyBoolCalculate;
185  top_level = false;
186  allow_jit = true;
187 }
188 
189 llvm::ArrayRef<OptionDefinition>
191  return llvm::makeArrayRef(g_expression_options);
192 }
193 
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),
204  m_repl_option(LLDB_OPT_SET_1, false, "repl", 'r', "Drop into REPL", false,
205  true),
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 
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"
281 }
282 
284 
286 
292  options.SetAutoApplyFixIts(false);
293  options.SetGenerateDebugInfo(false);
294 
296 
297  // Get out before we start doing things that expect a valid frame pointer.
298  if (exe_ctx.GetFramePtr() == nullptr)
299  return;
300 
301  Target *exe_target = exe_ctx.GetTargetPtr();
302  Target &target = exe_target ? *exe_target : GetDummyTarget();
303 
304  unsigned cursor_pos = request.GetRawCursorPos();
305  // Get the full user input including the suffix. The suffix is necessary
306  // as OptionsWithRaw will use it to detect if the cursor is cursor is in the
307  // argument part of in the raw input part of the arguments. If we cut of
308  // of the suffix then "expr -arg[cursor] --" would interpret the "-arg" as
309  // the raw input (as the "--" is hidden in the suffix).
310  llvm::StringRef code = request.GetRawLineWithUnusedSuffix();
311 
312  const std::size_t original_code_size = code.size();
313 
314  // Remove the first token which is 'expr' or some alias/abbreviation of that.
315  code = llvm::getToken(code).second.ltrim();
316  OptionsWithRaw args(code);
317  code = args.GetRawPart();
318 
319  // The position where the expression starts in the command line.
320  assert(original_code_size >= code.size());
321  std::size_t raw_start = original_code_size - code.size();
322 
323  // Check if the cursor is actually in the expression string, and if not, we
324  // exit.
325  // FIXME: We should complete the options here.
326  if (cursor_pos < raw_start)
327  return;
328 
329  // Make the cursor_pos again relative to the start of the code string.
330  assert(cursor_pos >= raw_start);
331  cursor_pos -= raw_start;
332 
333  auto language = exe_ctx.GetFrameRef().GetLanguage();
334 
336  lldb::UserExpressionSP expr(target.GetUserExpressionForLanguage(
337  code, llvm::StringRef(), language, UserExpression::eResultTypeAny,
338  options, nullptr, error));
339  if (error.Fail())
340  return;
341 
342  expr->Complete(exe_ctx, request, cursor_pos);
343 }
344 
347  CompilerType type(valobj.GetCompilerType());
348  CompilerType pointee;
349  if (!type.IsPointerType(&pointee))
350  return Status("as it does not refer to a pointer");
351  if (pointee.IsVoidType())
352  return Status("as it refers to a pointer to void");
353  return Status();
354 }
355 
362  options.SetKeepInMemory(true);
367  options.SetExecutionPolicy(
371 
372  bool auto_apply_fixits;
374  auto_apply_fixits = target.GetEnableAutoApplyFixIts();
375  else
376  auto_apply_fixits = m_command_options.auto_apply_fixits == eLazyBoolYes;
377 
378  options.SetAutoApplyFixIts(auto_apply_fixits);
380 
383 
384  // If there is any chance we are going to stop and want to see what went
385  // wrong with our expression, we should generate debug info
388  options.SetGenerateDebugInfo(true);
389 
390  if (m_command_options.timeout > 0)
391  options.SetTimeout(std::chrono::microseconds(m_command_options.timeout));
392  else
393  options.SetTimeout(llvm::None);
394  return options;
395 }
396 
397 bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr,
398  Stream &output_stream,
399  Stream &error_stream,
400  CommandReturnObject &result) {
401  // Don't use m_exe_ctx as this might be called asynchronously after the
402  // command object DoExecute has finished when doing multi-line expression
403  // that use an input reader...
405  Target *exe_target = exe_ctx.GetTargetPtr();
406  Target &target = exe_target ? *exe_target : GetDummyTarget();
407 
408  lldb::ValueObjectSP result_valobj_sp;
409  StackFrame *frame = exe_ctx.GetFramePtr();
410 
412  result.AppendErrorWithFormat(
413  "Can't disable JIT compilation for top-level expressions.\n");
414  return false;
415  }
416 
417  const EvaluateExpressionOptions options = GetEvalOptions(target);
418  ExpressionResults success = target.EvaluateExpression(
419  expr, frame, result_valobj_sp, options, &m_fixed_expression);
420 
421  // We only tell you about the FixIt if we applied it. The compiler errors
422  // will suggest the FixIt if it parsed.
423  if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
424  error_stream.Printf(" Fix-it applied, fixed expression was: \n %s\n",
425  m_fixed_expression.c_str());
426  }
427 
428  if (result_valobj_sp) {
429  Format format = m_format_options.GetFormat();
430 
431  if (result_valobj_sp->GetError().Success()) {
432  if (format != eFormatVoid) {
433  if (format != eFormatDefault)
434  result_valobj_sp->SetFormat(format);
435 
436  if (m_varobj_options.elem_count > 0) {
437  Status error(CanBeUsedForElementCountPrinting(*result_valobj_sp));
438  if (error.Fail()) {
439  result.AppendErrorWithFormat(
440  "expression cannot be used with --element-count %s\n",
441  error.AsCString(""));
442  return false;
443  }
444  }
445 
447  m_command_options.m_verbosity, format));
448  options.SetVariableFormatDisplayLanguage(
449  result_valobj_sp->GetPreferredDisplayLanguage());
450 
451  result_valobj_sp->Dump(output_stream, options);
452 
454  }
455  } else {
456  if (result_valobj_sp->GetError().GetError() ==
458  if (format != eFormatVoid && GetDebugger().GetNotifyVoid()) {
459  error_stream.PutCString("(void)\n");
460  }
461 
463  } else {
464  const char *error_cstr = result_valobj_sp->GetError().AsCString();
465  if (error_cstr && error_cstr[0]) {
466  const size_t error_cstr_len = strlen(error_cstr);
467  const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n';
468  if (strstr(error_cstr, "error:") != error_cstr)
469  error_stream.PutCString("error: ");
470  error_stream.Write(error_cstr, error_cstr_len);
471  if (!ends_with_newline)
472  error_stream.EOL();
473  } else {
474  error_stream.PutCString("error: unknown error\n");
475  }
476 
478  }
479  }
480  }
481 
482  return (success != eExpressionSetupError &&
483  success != eExpressionParseError);
484 }
485 
487  std::string &line) {
488  io_handler.SetIsDone(true);
489  // StreamSP output_stream =
490  // io_handler.GetDebugger().GetAsyncOutputStream();
491  // StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream();
492  StreamFileSP output_sp = io_handler.GetOutputStreamFileSP();
493  StreamFileSP error_sp = io_handler.GetErrorStreamFileSP();
494 
496  GetCommandInterpreter().GetDebugger().GetUseColor());
497  EvaluateExpression(line.c_str(), *output_sp, *error_sp, return_obj);
498  if (output_sp)
499  output_sp->Flush();
500  if (error_sp)
501  error_sp->Flush();
502 }
503 
505  StringList &lines) {
506  // An empty lines is used to indicate the end of input
507  const size_t num_lines = lines.GetSize();
508  if (num_lines > 0 && lines[num_lines - 1].empty()) {
509  // Remove the last empty line from "lines" so it doesn't appear in our
510  // resulting input and return true to indicate we are done getting lines
511  lines.PopBack();
512  return true;
513  }
514  return false;
515 }
516 
518  m_expr_lines.clear();
519  m_expr_line_count = 0;
520 
522  bool color_prompt = debugger.GetUseColor();
523  const bool multiple_lines = true; // Get multiple lines
524  IOHandlerSP io_handler_sp(
526  "lldb-expr", // Name of input reader for history
527  llvm::StringRef(), // No prompt
528  llvm::StringRef(), // Continuation prompt
529  multiple_lines, color_prompt,
530  1, // Show line numbers starting at 1
531  *this, nullptr));
532 
533  StreamFileSP output_sp = io_handler_sp->GetOutputStreamFileSP();
534  if (output_sp) {
535  output_sp->PutCString(
536  "Enter expressions, then terminate with an empty line to evaluate:\n");
537  output_sp->Flush();
538  }
539  debugger.RunIOHandlerAsync(io_handler_sp);
540 }
541 
544  CommandObjectExpression::CommandOptions command_options) {
545  command_options.OptionParsingStarting(&ctx);
546 
547  // Default certain settings for REPL regardless of the global settings.
548  command_options.unwind_on_error = false;
549  command_options.ignore_breakpoints = false;
550  command_options.debug = false;
551 
552  EvaluateExpressionOptions expr_options;
553  expr_options.SetUnwindOnError(command_options.unwind_on_error);
554  expr_options.SetIgnoreBreakpoints(command_options.ignore_breakpoints);
555  expr_options.SetTryAllThreads(command_options.try_all_threads);
556 
557  if (command_options.timeout > 0)
558  expr_options.SetTimeout(std::chrono::microseconds(command_options.timeout));
559  else
560  expr_options.SetTimeout(llvm::None);
561 
562  return expr_options;
563 }
564 
565 bool CommandObjectExpression::DoExecute(llvm::StringRef command,
566  CommandReturnObject &result) {
567  m_fixed_expression.clear();
568  auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
570 
571  if (command.empty()) {
573  return result.Succeeded();
574  }
575 
576  OptionsWithRaw args(command);
577  llvm::StringRef expr = args.GetRawPart();
578 
579  if (args.HasArgs()) {
580  if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, exe_ctx))
581  return false;
582 
584  Target &target = GetSelectedOrDummyTarget();
585  // Drop into REPL
586  m_expr_lines.clear();
587  m_expr_line_count = 0;
588 
589  Debugger &debugger = target.GetDebugger();
590 
591  // Check if the LLDB command interpreter is sitting on top of a REPL
592  // that launched it...
595  // the LLDB command interpreter is sitting on top of a REPL that
596  // launched it, so just say the command interpreter is done and
597  // fall back to the existing REPL
598  m_interpreter.GetIOHandler(false)->SetIsDone(true);
599  } else {
600  // We are launching the REPL on top of the current LLDB command
601  // interpreter, so just push one
602  bool initialize = false;
603  Status repl_error;
604  REPLSP repl_sp(target.GetREPL(repl_error, m_command_options.language,
605  nullptr, false));
606 
607  if (!repl_sp) {
608  initialize = true;
609  repl_sp = target.GetREPL(repl_error, m_command_options.language,
610  nullptr, true);
611  if (!repl_error.Success()) {
612  result.SetError(repl_error);
613  return result.Succeeded();
614  }
615  }
616 
617  if (repl_sp) {
618  if (initialize) {
619  repl_sp->SetEvaluateOptions(
621  repl_sp->SetFormatOptions(m_format_options);
622  repl_sp->SetValueObjectDisplayOptions(m_varobj_options);
623  }
624 
625  IOHandlerSP io_handler_sp(repl_sp->GetIOHandler());
626  io_handler_sp->SetIsDone(false);
627  debugger.RunIOHandlerAsync(io_handler_sp);
628  } else {
629  repl_error.SetErrorStringWithFormat(
630  "Couldn't create a REPL for %s",
632  result.SetError(repl_error);
633  return result.Succeeded();
634  }
635  }
636  }
637  // No expression following options
638  else if (expr.empty()) {
640  return result.Succeeded();
641  }
642  }
643 
644  Target &target = GetSelectedOrDummyTarget();
645  if (EvaluateExpression(expr, result.GetOutputStream(),
646  result.GetErrorStream(), result)) {
647 
648  if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) {
650  // FIXME: Can we figure out what the user actually typed (e.g. some alias
651  // for expr???)
652  // If we can it would be nice to show that.
653  std::string fixed_command("expression ");
654  if (args.HasArgs()) {
655  // Add in any options that might have been in the original command:
656  fixed_command.append(std::string(args.GetArgStringWithDelimiter()));
657  fixed_command.append(m_fixed_expression);
658  } else
659  fixed_command.append(m_fixed_expression);
660  history.AppendString(fixed_command);
661  }
662  // Increment statistics to record this expression evaluation success.
664  return true;
665  }
666 
667  // Increment statistics to record this expression evaluation failure.
670  return false;
671 }
lldb_private::CommandObject::GetSelectedOrDummyTarget
Target & GetSelectedOrDummyTarget(bool prefer_dummy=false)
Definition: CommandObject.cpp:938
lldb_private::OptionGroupFormat::OPTION_GROUP_GDB_FMT
static const uint32_t OPTION_GROUP_GDB_FMT
Definition: OptionGroupFormat.h:24
lldb_private::Debugger::CheckTopIOHandlerTypes
bool CheckTopIOHandlerTypes(IOHandler::Type top_type, IOHandler::Type second_top_type)
Definition: Debugger.cpp:934
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::CompletionRequest::GetRawCursorPos
unsigned GetRawCursorPos() const
Definition: CompletionRequest.h:132
lldb_private::CommandObject::GetDummyTarget
Target & GetDummyTarget()
Definition: CommandObject.cpp:934
lldb_private::CommandObjectExpression::CommandOptions::OptionParsingStarting
void OptionParsingStarting(ExecutionContext *execution_context) override
Definition: CommandObjectExpression.cpp:166
lldb_private::LanguageRuntimeDescriptionDisplayVerbosity
LanguageRuntimeDescriptionDisplayVerbosity
Definition: lldb-private-enumerations.h:160
lldb_private::eArgRepeatPlain
@ eArgRepeatPlain
Definition: lldb-private-enumerations.h:95
lldb_private::CommandReturnObject::SetError
void SetError(const Status &error, const char *fallback_error_cstr=nullptr)
Definition: CommandReturnObject.cpp:107
lldb::Format
Format
Display format definitions.
Definition: lldb-enumerations.h:155
lldb_private::CommandObjectExpression::CommandOptions::GetDefinitions
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Definition: CommandObjectExpression.cpp:190
lldb_private::EvaluateExpressionOptions::SetTimeout
void SetTimeout(const Timeout< std::micro > &timeout)
Definition: Target.h:326
lldb_private::EvaluateExpressionOptions::SetLanguage
void SetLanguage(lldb::LanguageType language)
Definition: Target.h:286
lldb_private::CommandObjectExpression::IOHandlerIsInputComplete
bool IOHandlerIsInputComplete(IOHandler &io_handler, StringList &lines) override
Called to determine whether typing enter after the last line in lines should end input.
Definition: CommandObjectExpression.cpp:482
lldb_private::Options::NotifyOptionParsingStarting
void NotifyOptionParsingStarting(ExecutionContext *execution_context)
Definition: Options.cpp:32
lldb::ExpressionResults
ExpressionResults
The results of expression evaluation.
Definition: lldb-enumerations.h:270
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
lldb_private::CommandObjectExpression::CommandOptions::unwind_on_error
bool unwind_on_error
Definition: CommandObjectExpression.h:39
lldb_private::eExecutionPolicyNever
@ eExecutionPolicyNever
Definition: lldb-private-enumerations.h:146
lldb_private::EvaluateExpressionOptions::SetExecutionPolicy
void SetExecutionPolicy(ExecutionPolicy policy=eExecutionPolicyAlways)
Definition: Target.h:280
lldb_private::CommandObjectExpression::CommandOptions::auto_apply_fixits
LazyBool auto_apply_fixits
Definition: CommandObjectExpression.h:49
lldb_private::CommandObject::CommandArgumentData
Definition: CommandObject.h:89
lldb_private::Debugger::RunIOHandlerAsync
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
Definition: Debugger.cpp:961
lldb_private::OptionGroup
Definition: Options.h:233
lldb_private::EvaluateExpressionOptions
Definition: Target.h:258
lldb::eExpressionSetupError
@ eExpressionSetupError
Definition: lldb-enumerations.h:272
lldb_private::CommandObjectExpression::CommandOptions::ignore_breakpoints
bool ignore_breakpoints
Definition: CommandObjectExpression.h:40
lldb_private::IOHandler::Type::REPL
@ REPL
lldb::eArgTypeExpression
@ eArgTypeExpression
Definition: lldb-enumerations.h:533
OptionArgParser.h
lldb_private::ExecutionContext::GetFramePtr
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Definition: ExecutionContext.h:408
lldb_private::CommandObjectExpression::CommandOptions
Definition: CommandObjectExpression.h:25
UserExpression.h
StackFrame.h
lldb_private::CommandObject::SetHelpLong
virtual void SetHelpLong(llvm::StringRef str)
Definition: CommandObject.cpp:90
lldb_private::CommandObject::CommandArgumentData::arg_repetition
ArgumentRepetitionType arg_repetition
Definition: CommandObject.h:92
CanBeUsedForElementCountPrinting
static lldb_private::Status CanBeUsedForElementCountPrinting(ValueObject &valobj)
Definition: CommandObjectExpression.cpp:324
lldb_private::Stream
Definition: Stream.h:28
lldb_private::CommandHistory
Definition: CommandHistory.h:21
lldb_private::CommandInterpreter::GetIOHandler
lldb::IOHandlerSP GetIOHandler(bool force_create=false, CommandInterpreterRunOptions *options=nullptr)
Language.h
lldb_private::OptionValueBoolean::GetCurrentValue
bool GetCurrentValue() const
Definition: OptionValueBoolean.h:66
CommandObjectExpression.h
lldb_private::CommandObject::ParseOptionsAndNotify
bool ParseOptionsAndNotify(Args &args, CommandReturnObject &result, OptionGroupOptions &group_options, ExecutionContext &exe_ctx)
Definition: CommandObject.cpp:341
lldb_private::Target::GetDebugger
Debugger & GetDebugger()
Definition: Target.h:999
CommandReturnObject.h
lldb_private::CommandObjectExpression::CommandOptions::allow_jit
bool allow_jit
Definition: CommandObjectExpression.h:41
Debugger.h
lldb_private::Target
Definition: Target.h:450
lldb_private::CommandObjectExpression::m_option_group
OptionGroupOptions m_option_group
Definition: CommandObjectExpression.h:89
lldb_private::EvaluateExpressionOptions::SetRetriesWithFixIts
void SetRetriesWithFixIts(uint64_t number_of_retries)
Definition: Target.h:405
Process.h
lldb_private::StringList::GetSize
size_t GetSize() const
Definition: StringList.cpp:68
lldb_private::eExecutionPolicyTopLevel
@ eExecutionPolicyTopLevel
Definition: lldb-private-enumerations.h:148
lldb_private::CommandObjectExpression::m_fixed_expression
std::string m_fixed_expression
Definition: CommandObjectExpression.h:96
lldb_private::IOHandlerDelegate::Completion
Completion
Definition: IOHandler.h:197
lldb_private::CommandObjectExpression::GetEvalOptions
EvaluateExpressionOptions GetEvalOptions(const Target &target)
Return the appropriate expression options used for evaluating the expression in the given target.
Definition: CommandObjectExpression.cpp:335
Target.h
lldb_private::CommandObject::m_arguments
std::vector< CommandArgumentEntry > m_arguments
Definition: CommandObject.h:366
GetExprOptions
static EvaluateExpressionOptions GetExprOptions(ExecutionContext &ctx, CommandObjectExpression::CommandOptions command_options)
Definition: CommandObjectExpression.cpp:521
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::IOHandler::Type::Expression
@ Expression
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
lldb_private::Options
Definition: Options.h:57
REPL.h
lldb_private::CommandObjectExpression::DoExecute
bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override
Definition: CommandObjectExpression.cpp:543
lldb_private::OptionGroupValueObjectDisplay::use_dynamic
lldb::DynamicValueType use_dynamic
Definition: OptionGroupValueObjectDisplay.h:52
lldb_private::EvaluateExpressionOptions::default_execution_policy
static constexpr ExecutionPolicy default_execution_policy
Definition: Target.h:273
lldb_private::CommandObjectExpression::GetMultilineExpression
void GetMultilineExpression()
Definition: CommandObjectExpression.cpp:495
LLDB_OPT_SET_1
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:113
lldb_private::CommandReturnObject::SetStatus
void SetStatus(lldb::ReturnStatus status)
Definition: CommandReturnObject.cpp:121
LLDB_OPT_SET_3
#define LLDB_OPT_SET_3
Definition: lldb-defines.h:115
lldb_private::Status::SetErrorStringWithFormat
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:256
lldb_private::OptionGroupFormat::GetFormat
lldb::Format GetFormat() const
Definition: OptionGroupFormat.h:44
lldb_private::CommandReturnObject::GetOutputStream
Stream & GetOutputStream()
Definition: CommandReturnObject.h:45
LLDB_OPT_SET_ALL
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:112
lldb_private::StringList
Definition: StringList.h:25
lldb_private::CommandObjectExpression::HandleCompletion
void HandleCompletion(CompletionRequest &request) override
This default version handles calling option argument completions and then calls HandleArgumentComplet...
Definition: CommandObjectExpression.cpp:265
lldb_private::IOHandler
Definition: IOHandler.h:46
lldb_private::CompilerType::IsVoidType
bool IsVoidType() const
Definition: CompilerType.cpp:236
lldb_private::EvaluateExpressionOptions::SetTryAllThreads
void SetTryAllThreads(bool try_others=true)
Definition: Target.h:338
lldb_private::OptionGroupOptions::Finalize
void Finalize()
Definition: Options.cpp:839
lldb_private::CommandObjectExpression::EvaluateExpression
bool EvaluateExpression(llvm::StringRef expr, Stream &output_stream, Stream &error_stream, CommandReturnObject &result)
Evaluates the given expression.
Definition: CommandObjectExpression.cpp:375
lldb_private::ExpressionFailure
@ ExpressionFailure
Definition: lldb-private-enumerations.h:219
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:214
lldb_private::CommandObjectExpression::m_expr_lines
std::string m_expr_lines
Definition: CommandObjectExpression.h:95
lldb::eReturnStatusFailed
@ eReturnStatusFailed
Definition: lldb-enumerations.h:265
lldb_private::Debugger
Definition: Debugger.h:70
lldb_private::CommandObject::m_interpreter
CommandInterpreter & m_interpreter
Definition: CommandObject.h:358
lldb_private::CommandObjectExpression::m_format_options
OptionGroupFormat m_format_options
Definition: CommandObjectExpression.h:90
lldb_private::CommandObject::CommandArgumentData::arg_type
lldb::CommandArgumentType arg_type
Definition: CommandObject.h:91
lldb_private::CommandReturnObject::GetErrorStream
Stream & GetErrorStream()
Definition: CommandReturnObject.h:55
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::CommandObjectExpression::~CommandObjectExpression
~CommandObjectExpression() override
lldb_private::EvaluateExpressionOptions::SetUnwindOnError
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:305
lldb_private::EvaluateExpressionOptions::SetKeepInMemory
void SetKeepInMemory(bool keep=true)
Definition: Target.h:315
lldb_private::CommandObjectExpression::CommandOptions::~CommandOptions
~CommandOptions() override
lldb_private::CommandObjectExpression::CommandOptions::try_all_threads
bool try_all_threads
Definition: CommandObjectExpression.h:46
lldb_private::CommandObjectRaw
Definition: CommandObject.h:395
lldb_private::TargetProperties::GetEnableAutoApplyFixIts
bool GetEnableAutoApplyFixIts() const
Definition: Target.cpp:4075
lldb_private::CommandObjectExpression::m_command_options
CommandOptions m_command_options
Definition: CommandObjectExpression.h:93
lldb_private::CommandObjectExpression::CommandOptions::debug
bool debug
Definition: CommandObjectExpression.h:44
lldb_private::OptionGroupValueObjectDisplay::use_objc
bool use_objc
Definition: OptionGroupValueObjectDisplay.h:45
lldb_private::CommandObjectExpression::m_repl_option
OptionGroupBoolean m_repl_option
Definition: CommandObjectExpression.h:92
lldb::eFormatVoid
@ eFormatVoid
Do not print this.
Definition: lldb-enumerations.h:200
lldb_private::EvaluateExpressionOptions::SetIgnoreBreakpoints
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:309
lldb_private::CommandObjectExpression::GetOptions
Options * GetOptions() override
Definition: CommandObjectExpression.cpp:263
lldb_private::CommandObjectExpression::CommandOptions::m_verbosity
LanguageRuntimeDescriptionDisplayVerbosity m_verbosity
Definition: CommandObjectExpression.h:48
lldb_private::IOHandler::SetIsDone
virtual void SetIsDone(bool b)
Definition: IOHandler.h:90
lldb_private::Language::GetLanguageTypeFromString
static lldb::LanguageType GetLanguageTypeFromString(const char *string)=delete
lldb_private::CommandObjectExpression::m_varobj_options
OptionGroupValueObjectDisplay m_varobj_options
Definition: CommandObjectExpression.h:91
lldb_private::ExecutionContext::GetProcessSP
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
Definition: ExecutionContext.h:459
lldb_private::StringList::PopBack
void PopBack()
Definition: StringList.h:75
lldb_private::OptionGroupFormat::OPTION_GROUP_FORMAT
static const uint32_t OPTION_GROUP_FORMAT
Definition: OptionGroupFormat.h:23
lldb_private::OptionArgParser::ToBoolean
static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr)
Definition: OptionArgParser.cpp:18
lldb_private::OptionGroupValueObjectDisplay::GetAsDumpOptions
DumpValueObjectOptions GetAsDumpOptions(LanguageRuntimeDescriptionDisplayVerbosity lang_descr_verbosity=eLanguageRuntimeDescriptionDisplayVerbosityFull, lldb::Format format=lldb::eFormatDefault, lldb::TypeSummaryImplSP summary_sp=lldb::TypeSummaryImplSP())
Definition: OptionGroupValueObjectDisplay.cpp:183
lldb_private::Status
Definition: Status.h:44
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::CommandObjectExpression::CommandOptions::SetOptionValue
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
Definition: CommandObjectExpression.cpp:51
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::CommandReturnObject
Definition: CommandReturnObject.h:25
lldb_private::CommandObjectExpression::IOHandlerInputComplete
void IOHandlerInputComplete(IOHandler &io_handler, std::string &line) override
Called when a line or lines have been retrieved.
Definition: CommandObjectExpression.cpp:464
lldb_private::Target::GetREPL
lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create)
Definition: Target.cpp:216
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
lldb_private::EvaluateExpressionOptions::SetUseDynamic
void SetUseDynamic(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
Definition: Target.h:320
lldb_private::EvaluateExpressionOptions::SetCoerceToId
void SetCoerceToId(bool coerce=true)
Definition: Target.h:301
lldb_private::CommandInterpreter::GetDebugger
Debugger & GetDebugger()
Definition: CommandInterpreter.h:393
lldb::eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishResult
Definition: lldb-enumerations.h:261
lldb_private::eLanguageRuntimeDescriptionDisplayVerbosityFull
@ eLanguageRuntimeDescriptionDisplayVerbosityFull
Definition: lldb-private-enumerations.h:164
lldb_private::OptionArgParser::ToOptionEnum
static int64_t ToOptionEnum(llvm::StringRef s, const OptionEnumValues &enum_values, int32_t fail_value, Status &error)
Definition: OptionArgParser.cpp:47
lldb_private::CommandObjectExpression::m_expr_line_count
uint32_t m_expr_line_count
Definition: CommandObjectExpression.h:94
lldb_private::Target::EvaluateExpression
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2380
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::OptionGroupBoolean::GetOptionValue
OptionValueBoolean & GetOptionValue()
Definition: OptionGroupBoolean.h:39
g_description_verbosity_type
static constexpr OptionEnumValueElement g_description_verbosity_type[]
Definition: CommandObjectExpression.cpp:31
lldb_private::ValueObject::GetCompilerType
CompilerType GetCompilerType()
Definition: ValueObject.h:352
lldb_private::CommandObjectExpression::CommandOptions::language
lldb::LanguageType language
Definition: CommandObjectExpression.h:47
lldb_private::EvaluateExpressionOptions::SetGenerateDebugInfo
void SetGenerateDebugInfo(bool b)
Definition: Target.h:354
lldb_private::Expression::eResultTypeAny
@ eResultTypeAny
Definition: Expression.h:35
lldb_private::OptionsWithRaw
Definition: Args.h:319
lldb_private::CommandReturnObject::Succeeded
bool Succeeded()
Definition: CommandReturnObject.cpp:125
lldb_private::CommandObject::GetCommandInterpreter
CommandInterpreter & GetCommandInterpreter()
Definition: CommandObject.h:124
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::Debugger::GetUseColor
bool GetUseColor() const
Definition: Debugger.cpp:343
lldb_private::UserExpression::kNoResult
static const Status::ValueType kNoResult
ValueObject::GetError() returns this if there is no result from the expression.
Definition: UserExpression.h:265
lldb_private::ExpressionSuccessful
@ ExpressionSuccessful
Definition: lldb-private-enumerations.h:218
lldb_private::CommandInterpreter::GetCommandHistory
CommandHistory & GetCommandHistory()
Definition: CommandInterpreter.h:468
lldb_private::Target::GetUserExpressionForLanguage
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
Definition: Target.cpp:2271
lldb_private::DumpValueObjectOptions
Definition: DumpValueObjectOptions.h:22
lldb_private::TargetProperties::GetNumberOfRetriesWithFixits
uint64_t GetNumberOfRetriesWithFixits() const
Definition: Target.cpp:4081
lldb_private::CommandReturnObject::AppendErrorWithFormat
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:46
lldb_private::IOHandlerDelegate
A delegate class for use with IOHandler subclasses.
Definition: IOHandler.h:195
OptionParser.h
lldb_private::OptionGroupOptions::Append
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:810
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::TargetProperties::GetEnableNotifyAboutFixIts
bool GetEnableNotifyAboutFixIts() const
Definition: Target.cpp:4087
lldb_private::IOHandler::Type::CommandInterpreter
@ CommandInterpreter
lldb_private::Stream::Write
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition: Stream.h:101
CommandInterpreter.h
lldb_private::CommandInterpreter::GetExecutionContext
ExecutionContext GetExecutionContext() const
lldb_private::OptionGroupValueObjectDisplay::elem_count
uint32_t elem_count
Definition: OptionGroupValueObjectDisplay.h:51
lldb_private::CommandObjectExpression::CommandObjectExpression
CommandObjectExpression(CommandInterpreter &interpreter)
Definition: CommandObjectExpression.cpp:194
lldb_private::EvaluateExpressionOptions::SetDebug
void SetDebug(bool b)
Definition: Target.h:346
lldb_private::CommandObjectExpression::CommandOptions::top_level
bool top_level
Definition: CommandObjectExpression.h:38
lldb_private::CommandObjectExpression::CommandOptions::timeout
uint32_t timeout
Definition: CommandObjectExpression.h:45
lldb::eExpressionParseError
@ eExpressionParseError
Definition: lldb-enumerations.h:273
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::CompletionRequest::GetRawLineWithUnusedSuffix
llvm::StringRef GetRawLineWithUnusedSuffix() const
Returns the full raw user input used to create this CompletionRequest.
Definition: CompletionRequest.h:130
lldb_private::CommandObject::CommandArgumentEntry
std::vector< CommandArgumentData > CommandArgumentEntry
Definition: CommandObject.h:105
lldb_private::Language::GetNameForLanguageType
static const char * GetNameForLanguageType(lldb::LanguageType language)
Definition: Language.cpp:217
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::eLanguageRuntimeDescriptionDisplayVerbosityCompact
@ eLanguageRuntimeDescriptionDisplayVerbosityCompact
Definition: lldb-private-enumerations.h:161
LLDB_OPT_SET_2
#define LLDB_OPT_SET_2
Definition: lldb-defines.h:114
lldb
Definition: SBAddress.h:15
lldb_private::Expression
Definition: Expression.h:33
lldb_private::IOHandler::GetOutputStreamFileSP
lldb::StreamFileSP GetOutputStreamFileSP()
Definition: IOHandler.cpp:108
lldb::eFormatDefault
@ eFormatDefault
Definition: lldb-enumerations.h:156
DescriptionVerbosityTypes
static constexpr OptionEnumValues DescriptionVerbosityTypes()
Definition: CommandObjectExpression.cpp:44
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:200
lldb_private::Target::IncrementStats
void IncrementStats(lldb_private::StatisticKind key)
Definition: Target.h:1462
lldb_private::CommandHistory::AppendString
void AppendString(llvm::StringRef str, bool reject_if_dupe=true)
Definition: CommandHistory.cpp:78
lldb_private::IOHandler::GetErrorStreamFileSP
lldb::StreamFileSP GetErrorStreamFileSP()
Definition: IOHandler.cpp:110
lldb_private::CompletionRequest
Definition: CompletionRequest.h:100
lldb_private::CommandObject::GetDebugger
Debugger & GetDebugger()
Definition: CommandObject.cpp:51
lldb_private::IOHandlerEditline
Definition: IOHandler.h:332
lldb_private::EvaluateExpressionOptions::SetAutoApplyFixIts
void SetAutoApplyFixIts(bool b)
Definition: Target.h:401