LLDB  mainline
UserExpression.cpp
Go to the documentation of this file.
1 //===-- UserExpression.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 <cstdio>
10 #include <sys/types.h>
11 
12 #include <cstdlib>
13 #include <map>
14 #include <string>
15 
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/StreamFile.h"
25 #include "lldb/Host/HostInfo.h"
26 #include "lldb/Symbol/Block.h"
27 #include "lldb/Symbol/Function.h"
28 #include "lldb/Symbol/ObjectFile.h"
30 #include "lldb/Symbol/Type.h"
31 #include "lldb/Symbol/TypeSystem.h"
34 #include "lldb/Target/Process.h"
35 #include "lldb/Target/StackFrame.h"
36 #include "lldb/Target/Target.h"
37 #include "lldb/Target/ThreadPlan.h"
40 #include "lldb/Utility/LLDBLog.h"
41 #include "lldb/Utility/Log.h"
43 
44 using namespace lldb_private;
45 
47 
49  llvm::StringRef expr, llvm::StringRef prefix,
50  lldb::LanguageType language,
51  ResultType desired_type,
52  const EvaluateExpressionOptions &options)
53  : Expression(exe_scope), m_expr_text(std::string(expr)),
54  m_expr_prefix(std::string(prefix)), m_language(language),
55  m_desired_type(desired_type), m_options(options) {}
56 
58 
60  m_jit_process_wp = exe_ctx.GetProcessSP();
61 
62  lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
63 
64  if (frame_sp)
65  m_address = frame_sp->GetFrameCodeAddress();
66 }
67 
69  lldb::TargetSP &target_sp,
70  lldb::ProcessSP &process_sp,
71  lldb::StackFrameSP &frame_sp) {
72  lldb::ProcessSP expected_process_sp = m_jit_process_wp.lock();
73  process_sp = exe_ctx.GetProcessSP();
74 
75  if (process_sp != expected_process_sp)
76  return false;
77 
78  process_sp = exe_ctx.GetProcessSP();
79  target_sp = exe_ctx.GetTargetSP();
80  frame_sp = exe_ctx.GetFrameSP();
81 
82  if (m_address.IsValid()) {
83  if (!frame_sp)
84  return false;
86  frame_sp->GetFrameCodeAddress(),
87  target_sp.get()) == 0);
88  }
89 
90  return true;
91 }
92 
94  lldb::TargetSP target_sp;
95  lldb::ProcessSP process_sp;
96  lldb::StackFrameSP frame_sp;
97 
98  return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp);
99 }
100 
101 lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
102  ConstString &object_name,
103  Status &err) {
104  err.Clear();
105 
106  if (!frame_sp) {
108  "Couldn't load '%s' because the context is incomplete",
109  object_name.AsCString());
110  return LLDB_INVALID_ADDRESS;
111  }
112 
113  lldb::VariableSP var_sp;
114  lldb::ValueObjectSP valobj_sp;
115 
116  valobj_sp = frame_sp->GetValueForVariableExpressionPath(
117  object_name.GetStringRef(), lldb::eNoDynamicValues,
122  var_sp, err);
123 
124  if (!err.Success() || !valobj_sp.get())
125  return LLDB_INVALID_ADDRESS;
126 
127  lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
128 
129  if (ret == LLDB_INVALID_ADDRESS) {
131  "Couldn't load '%s' because its value couldn't be evaluated",
132  object_name.AsCString());
133  return LLDB_INVALID_ADDRESS;
134  }
135 
136  return ret;
137 }
138 
141  const EvaluateExpressionOptions &options,
142  llvm::StringRef expr, llvm::StringRef prefix,
143  lldb::ValueObjectSP &result_valobj_sp, Status &error,
144  std::string *fixed_expression, ValueObject *ctx_obj) {
146 
147  if (ctx_obj) {
148  static unsigned const ctx_type_mask =
149  lldb::TypeFlags::eTypeIsClass | lldb::TypeFlags::eTypeIsStructUnion;
150  if (!(ctx_obj->GetTypeInfo() & ctx_type_mask)) {
151  LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a context object of "
152  "an invalid type, can't run expressions.");
153  error.SetErrorString("a context object of an invalid type passed");
155  }
156  }
157 
158  lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
159  lldb::LanguageType language = options.GetLanguage();
160  const ResultType desired_type = options.DoesCoerceToId()
164 
165  Target *target = exe_ctx.GetTargetPtr();
166  if (!target) {
167  LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a NULL target, can't "
168  "run expressions.");
169  error.SetErrorString("expression passed a null target");
171  }
172 
173  Process *process = exe_ctx.GetProcessPtr();
174 
175  if (process == nullptr || process->GetState() != lldb::eStateStopped) {
176  if (execution_policy == eExecutionPolicyAlways) {
177  LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but "
178  "is not constant ==");
179 
180  error.SetErrorString("expression needed to run but couldn't");
181 
182  return execution_results;
183  }
184  }
185 
186  // Explicitly force the IR interpreter to evaluate the expression when the
187  // there is no process that supports running the expression for us. Don't
188  // change the execution policy if we have the special top-level policy that
189  // doesn't contain any expression and there is nothing to interpret.
190  if (execution_policy != eExecutionPolicyTopLevel &&
191  (process == nullptr || !process->CanJIT()))
192  execution_policy = eExecutionPolicyNever;
193 
194  // We need to set the expression execution thread here, turns out parse can
195  // call functions in the process of looking up symbols, which will escape the
196  // context set by exe_ctx passed to Execute.
197  lldb::ThreadSP thread_sp = exe_ctx.GetThreadSP();
198  ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher(
199  thread_sp);
200 
201  llvm::StringRef full_prefix;
202  llvm::StringRef option_prefix(options.GetPrefix());
203  std::string full_prefix_storage;
204  if (!prefix.empty() && !option_prefix.empty()) {
205  full_prefix_storage = std::string(prefix);
206  full_prefix_storage.append(std::string(option_prefix));
207  full_prefix = full_prefix_storage;
208  } else if (!prefix.empty())
209  full_prefix = prefix;
210  else
211  full_prefix = option_prefix;
212 
213  // If the language was not specified in the expression command, set it to the
214  // language in the target's properties if specified, else default to the
215  // langage for the frame.
216  if (language == lldb::eLanguageTypeUnknown) {
217  if (target->GetLanguage() != lldb::eLanguageTypeUnknown)
218  language = target->GetLanguage();
219  else if (StackFrame *frame = exe_ctx.GetFramePtr())
220  language = frame->GetLanguage();
221  }
222 
223  lldb::UserExpressionSP user_expression_sp(
224  target->GetUserExpressionForLanguage(expr, full_prefix, language,
225  desired_type, options, ctx_obj,
226  error));
227  if (error.Fail()) {
228  LLDB_LOG(log, "== [UserExpression::Evaluate] Getting expression: {0} ==",
229  error.AsCString());
231  }
232 
233  LLDB_LOG(log, "== [UserExpression::Evaluate] Parsing expression {0} ==",
234  expr.str());
235 
236  const bool keep_expression_in_memory = true;
237  const bool generate_debug_info = options.GetGenerateDebugInfo();
238 
240  error.SetErrorString("expression interrupted by callback before parse");
241  result_valobj_sp = ValueObjectConstResult::Create(
244  }
245 
246  DiagnosticManager diagnostic_manager;
247 
248  bool parse_success =
249  user_expression_sp->Parse(diagnostic_manager, exe_ctx, execution_policy,
250  keep_expression_in_memory, generate_debug_info);
251 
252  // Calculate the fixed expression always, since we need it for errors.
253  std::string tmp_fixed_expression;
254  if (fixed_expression == nullptr)
255  fixed_expression = &tmp_fixed_expression;
256 
257  *fixed_expression = user_expression_sp->GetFixedText().str();
258 
259  // If there is a fixed expression, try to parse it:
260  if (!parse_success) {
261  // Delete the expression that failed to parse before attempting to parse
262  // the next expression.
263  user_expression_sp.reset();
264 
265  execution_results = lldb::eExpressionParseError;
266  if (!fixed_expression->empty() && options.GetAutoApplyFixIts()) {
267  const uint64_t max_fix_retries = options.GetRetriesWithFixIts();
268  for (uint64_t i = 0; i < max_fix_retries; ++i) {
269  // Try parsing the fixed expression.
270  lldb::UserExpressionSP fixed_expression_sp(
272  fixed_expression->c_str(), full_prefix, language, desired_type,
273  options, ctx_obj, error));
274  DiagnosticManager fixed_diagnostic_manager;
275  parse_success = fixed_expression_sp->Parse(
276  fixed_diagnostic_manager, exe_ctx, execution_policy,
277  keep_expression_in_memory, generate_debug_info);
278  if (parse_success) {
279  diagnostic_manager.Clear();
280  user_expression_sp = fixed_expression_sp;
281  break;
282  } else {
283  // The fixed expression also didn't parse. Let's check for any new
284  // Fix-Its we could try.
285  if (!fixed_expression_sp->GetFixedText().empty()) {
286  *fixed_expression = fixed_expression_sp->GetFixedText().str();
287  } else {
288  // Fixed expression didn't compile without a fixit, don't retry and
289  // don't tell the user about it.
290  fixed_expression->clear();
291  break;
292  }
293  }
294  }
295  }
296 
297  if (!parse_success) {
298  std::string msg;
299  {
300  llvm::raw_string_ostream os(msg);
301  os << "expression failed to parse:\n";
302  if (!diagnostic_manager.Diagnostics().empty())
303  os << diagnostic_manager.GetString();
304  else
305  os << "unknown error";
306  if (target->GetEnableNotifyAboutFixIts() && fixed_expression &&
307  !fixed_expression->empty())
308  os << "\nfixed expression suggested:\n " << *fixed_expression;
309  }
310  error.SetExpressionError(execution_results, msg.c_str());
311  }
312  }
313 
314  if (parse_success) {
315  lldb::ExpressionVariableSP expr_result;
316 
317  if (execution_policy == eExecutionPolicyNever &&
318  !user_expression_sp->CanInterpret()) {
319  LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but "
320  "is not constant ==");
321 
322  if (!diagnostic_manager.Diagnostics().size())
323  error.SetExpressionError(lldb::eExpressionSetupError,
324  "expression needed to run but couldn't");
325  } else if (execution_policy == eExecutionPolicyTopLevel) {
328  } else {
330  error.SetExpressionError(
332  "expression interrupted by callback before execution");
333  result_valobj_sp = ValueObjectConstResult::Create(
336  }
337 
338  diagnostic_manager.Clear();
339 
340  LLDB_LOG(log, "== [UserExpression::Evaluate] Executing expression ==");
341 
342  execution_results =
343  user_expression_sp->Execute(diagnostic_manager, exe_ctx, options,
344  user_expression_sp, expr_result);
345 
346  if (execution_results != lldb::eExpressionCompleted) {
347  LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed "
348  "abnormally ==");
349 
350  if (!diagnostic_manager.Diagnostics().size())
351  error.SetExpressionError(
352  execution_results, "expression failed to execute, unknown error");
353  else
354  error.SetExpressionError(execution_results,
355  diagnostic_manager.GetString().c_str());
356  } else {
357  if (expr_result) {
358  result_valobj_sp = expr_result->GetValueObject();
359  result_valobj_sp->SetPreferredDisplayLanguage(language);
360 
361  LLDB_LOG(log,
362  "== [UserExpression::Evaluate] Execution completed "
363  "normally with result {0} ==",
364  result_valobj_sp->GetValueAsCString());
365  } else {
366  LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed "
367  "normally with no result ==");
368 
370  }
371  }
372  }
373  }
374 
376  error.SetExpressionError(
378  "expression interrupted by callback after complete");
380  }
381 
382  if (result_valobj_sp.get() == nullptr) {
383  result_valobj_sp = ValueObjectConstResult::Create(
385  }
386 
387  return execution_results;
388 }
389 
392  ExecutionContext &exe_ctx,
393  const EvaluateExpressionOptions &options,
394  lldb::UserExpressionSP &shared_ptr_to_me,
395  lldb::ExpressionVariableSP &result_var) {
396  lldb::ExpressionResults expr_result = DoExecute(
397  diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var);
398  Target *target = exe_ctx.GetTargetPtr();
399  if (options.GetResultIsInternal() && result_var && target) {
400  if (auto *persistent_state =
402  persistent_state->RemovePersistentVariable(result_var);
403  }
404  return expr_result;
405 }
lldb_private::UserExpression::InstallContext
void InstallContext(ExecutionContext &exe_ctx)
Populate m_in_cplusplus_method and m_in_objectivec_method based on the environment.
Definition: UserExpression.cpp:59
Block.h
lldb_private::UserExpression::m_address
Address m_address
The address the process is stopped in.
Definition: UserExpression.h:292
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::UserExpression::~UserExpression
~UserExpression() override
Destructor.
ExpressionVariable.h
lldb_private::ExecutionContext::GetThreadSP
const lldb::ThreadSP & GetThreadSP() const
Get accessor to get the thread shared pointer.
Definition: ExecutionContext.h:464
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb_private::ExecutionPolicy
ExecutionPolicy
Expression execution policies.
Definition: lldb-private-enumerations.h:144
lldb::eNoDynamicValues
@ eNoDynamicValues
Definition: lldb-enumerations.h:495
lldb_private::ExecutionContext::GetProcessPtr
Process * GetProcessPtr() const
Returns a pointer to the process object.
Definition: ExecutionContext.cpp:206
lldb::ExpressionResults
ExpressionResults
The results of expression evaluation.
Definition: lldb-enumerations.h:270
lldb_private::Expression::m_jit_process_wp
lldb::ProcessWP m_jit_process_wp
Expression's always have to have a target...
Definition: Expression.h:93
lldb_private::Process
Definition: Process.h:338
lldb_private::EvaluateExpressionOptions::DoesCoerceToId
bool DoesCoerceToId() const
Definition: Target.h:302
lldb_private::eExecutionPolicyNever
@ eExecutionPolicyNever
Definition: lldb-private-enumerations.h:146
lldb_private::EvaluateExpressionOptions::GetPrefix
const char * GetPrefix() const
Definition: Target.h:304
Module.h
lldb_private::EvaluateExpressionOptions
Definition: Target.h:272
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb::eExpressionSetupError
@ eExpressionSetupError
Definition: lldb-enumerations.h:272
lldb_private::ExecutionContext::GetFramePtr
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Definition: ExecutionContext.h:408
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
UserExpression.h
StackFrame.h
lldb_private::UserExpression::Evaluate
static lldb::ExpressionResults Evaluate(ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, llvm::StringRef expr_cstr, llvm::StringRef expr_prefix, lldb::ValueObjectSP &result_valobj_sp, Status &error, std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Evaluate one expression in the scratch context of the target passed in the exe_ctx and return its res...
Definition: UserExpression.cpp:140
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::eExecutionPolicyAlways
@ eExecutionPolicyAlways
Definition: lldb-private-enumerations.h:147
lldb_private::EvaluateExpressionOptions::GetAutoApplyFixIts
bool GetAutoApplyFixIts() const
Definition: Target.h:417
IRInterpreter.h
lldb_private::StackFrame::eExpressionPathOptionsNoFragileObjcIvar
@ eExpressionPathOptionsNoFragileObjcIvar
Definition: StackFrame.h:45
lldb_private::Target
Definition: Target.h:464
lldb_private::Process::GetState
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1294
lldb_private::DiagnosticManager::GetString
std::string GetString(char separator='\n')
Definition: DiagnosticManager.cpp:47
Process.h
lldb_private::eExecutionPolicyTopLevel
@ eExecutionPolicyTopLevel
Definition: lldb-private-enumerations.h:148
lldb_private::EvaluateExpressionOptions::GetGenerateDebugInfo
bool GetGenerateDebugInfo() const
Definition: Target.h:366
lldb_private::Process::CanJIT
bool CanJIT()
Determines whether executing JIT-compiled code in this process is possible.
Definition: Process.cpp:2295
lldb_private::Expression::ResultType
ResultType
Definition: Expression.h:35
lldb::eStateStopped
@ eStateStopped
Process or thread is stopped and can be examined.
Definition: lldb-enumerations.h:84
Target.h
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
Log.h
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::StackFrame::eExpressionPathOptionCheckPtrVsMember
@ eExpressionPathOptionCheckPtrVsMember
Definition: StackFrame.h:44
lldb::eExpressionCompleted
@ eExpressionCompleted
Definition: lldb-enumerations.h:271
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:255
StreamString.h
Type.h
lldb_private::ConstString
Definition: ConstString.h:40
lldb::eExpressionEvaluationComplete
@ eExpressionEvaluationComplete
Definition: lldb-enumerations.h:960
lldb_private::UserExpression::GetObjectPointer
static lldb::addr_t GetObjectPointer(lldb::StackFrameSP frame_sp, ConstString &object_name, Status &err)
Definition: UserExpression.cpp:101
lldb_private::StackFrame::eExpressionPathOptionsNoSyntheticArrayRange
@ eExpressionPathOptionsNoSyntheticArrayRange
Definition: StackFrame.h:47
lldb::eErrorTypeGeneric
@ eErrorTypeGeneric
Generic errors that can be any value.
Definition: lldb-enumerations.h:308
lldb::eExpressionEvaluationParse
@ eExpressionEvaluationParse
Definition: lldb-enumerations.h:957
IRExecutionUnit.h
HostInfo.h
lldb_private::Target::GetPersistentExpressionStateForLanguage
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2339
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
TypeSystem.h
lldb::eExpressionInterrupted
@ eExpressionInterrupted
Definition: lldb-enumerations.h:275
lldb_private::LLDBLog::Step
@ Step
lldb_private::Address::CompareLoadAddress
static int CompareLoadAddress(const Address &lhs, const Address &rhs, Target *target)
Definition: Address.cpp:935
VariableList.h
ObjectFile.h
lldb_private::ThreadList::ExpressionExecutionThreadPusher
Definition: ThreadList.h:47
ValueObjectConstResult.h
ThreadPlan.h
lldb_private::StackFrame::eExpressionPathOptionsNoSyntheticChildren
@ eExpressionPathOptionsNoSyntheticChildren
Definition: StackFrame.h:46
StreamFile.h
lldb_private::ExecutionContext::GetProcessSP
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
Definition: ExecutionContext.h:459
lldb_private::DiagnosticManager::Diagnostics
const DiagnosticList & Diagnostics()
Definition: DiagnosticManager.h:100
Materializer.h
lldb_private::Status
Definition: Status.h:44
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::EvaluateExpressionOptions::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Target.h:298
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::ExecutionContext::GetBestExecutionContextScope
ExecutionContextScope * GetBestExecutionContextScope() const
Definition: ExecutionContext.cpp:214
lldb_private::UserExpression::m_language
lldb::LanguageType m_language
The language to use when parsing (eLanguageTypeUnknown means use defaults)
Definition: UserExpression.h:299
lldb_private::ExecutionContext::GetFrameSP
const lldb::StackFrameSP & GetFrameSP() const
Get accessor to get the frame shared pointer.
Definition: ExecutionContext.h:469
ThreadPlanCallUserExpression.h
lldb_private::DiagnosticManager
Definition: DiagnosticManager.h:93
lldb_private::Expression::eResultTypeAny
@ eResultTypeAny
Definition: Expression.h:35
lldb_private::ValueObject::GetTypeInfo
virtual uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr)
Definition: ValueObject.h:378
lldb_private::UserExpression::Execute
lldb::ExpressionResults Execute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, lldb::UserExpressionSP &shared_ptr_to_me, lldb::ExpressionVariableSP &result)
Execute the parsed expression by callinng the derived class's DoExecute method.
Definition: UserExpression.cpp:391
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
lldb_private::ExecutionContext::GetTargetSP
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
Definition: ExecutionContext.h:454
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:263
Function.h
lldb_private::ValueObjectConstResult::Create
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, uint32_t addr_byte_size, lldb::addr_t address=LLDB_INVALID_ADDRESS)
Definition: ValueObjectConstResult.cpp:28
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::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:2352
DiagnosticManager.h
lldb_private::DiagnosticManager::Clear
void Clear()
Definition: DiagnosticManager.h:95
lldb_private::UserExpression::UserExpression
UserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, ResultType desired_type, const EvaluateExpressionOptions &options)
Constructor.
Definition: UserExpression.cpp:48
lldb_private::EvaluateExpressionOptions::GetExecutionPolicy
ExecutionPolicy GetExecutionPolicy() const
Definition: Target.h:292
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TargetProperties::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Target.cpp:4298
lldb_private::EvaluateExpressionOptions::GetResultIsInternal
bool GetResultIsInternal() const
Definition: Target.h:413
lldb_private::TargetProperties::GetEnableNotifyAboutFixIts
bool GetEnableNotifyAboutFixIts() const
Definition: Target.cpp:4185
lldb_private::UserExpression::ID
static char ID
LLVM RTTI support.
Definition: UserExpression.h:37
lldb_private::Status::Clear
void Clear()
Clear the object state.
Definition: Status.cpp:167
ConstString.h
lldb_private::EvaluateExpressionOptions::InvokeCancelCallback
bool InvokeCancelCallback(lldb::ExpressionEvaluationPhase phase) const
Definition: Target.h:387
lldb_private::UserExpression::LockAndCheckContext
bool LockAndCheckContext(ExecutionContext &exe_ctx, lldb::TargetSP &target_sp, lldb::ProcessSP &process_sp, lldb::StackFrameSP &frame_sp)
Definition: UserExpression.cpp:68
lldb::eExpressionParseError
@ eExpressionParseError
Definition: lldb-enumerations.h:273
lldb_private::Log
Definition: Log.h:48
SymbolVendor.h
lldb_private::EvaluateExpressionOptions::GetRetriesWithFixIts
uint64_t GetRetriesWithFixIts() const
Definition: Target.h:423
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:235
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::LLDBLog::Expressions
@ Expressions
lldb_private::Expression
Definition: Expression.h:33
lldb::eExpressionEvaluationExecution
@ eExpressionEvaluationExecution
Definition: lldb-enumerations.h:959
lldb_private::UserExpression::DoExecute
virtual lldb::ExpressionResults DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options, lldb::UserExpressionSP &shared_ptr_to_me, lldb::ExpressionVariableSP &result)=0
LLDBLog.h
lldb_private::Expression::eResultTypeId
@ eResultTypeId
Definition: Expression.h:35
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:198
ExecutionContext.h
lldb_private::UserExpression::MatchesContext
bool MatchesContext(ExecutionContext &exe_ctx)
Definition: UserExpression.cpp:93