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/Log.h"
42 
43 using namespace lldb_private;
44 
46 
48  llvm::StringRef expr, llvm::StringRef prefix,
49  lldb::LanguageType language,
50  ResultType desired_type,
51  const EvaluateExpressionOptions &options)
52  : Expression(exe_scope), m_expr_text(std::string(expr)),
53  m_expr_prefix(std::string(prefix)), m_language(language),
54  m_desired_type(desired_type), m_options(options) {}
55 
57 
59  m_jit_process_wp = exe_ctx.GetProcessSP();
60 
61  lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
62 
63  if (frame_sp)
64  m_address = frame_sp->GetFrameCodeAddress();
65 }
66 
68  lldb::TargetSP &target_sp,
69  lldb::ProcessSP &process_sp,
70  lldb::StackFrameSP &frame_sp) {
71  lldb::ProcessSP expected_process_sp = m_jit_process_wp.lock();
72  process_sp = exe_ctx.GetProcessSP();
73 
74  if (process_sp != expected_process_sp)
75  return false;
76 
77  process_sp = exe_ctx.GetProcessSP();
78  target_sp = exe_ctx.GetTargetSP();
79  frame_sp = exe_ctx.GetFrameSP();
80 
81  if (m_address.IsValid()) {
82  if (!frame_sp)
83  return false;
85  frame_sp->GetFrameCodeAddress(),
86  target_sp.get()) == 0);
87  }
88 
89  return true;
90 }
91 
93  lldb::TargetSP target_sp;
94  lldb::ProcessSP process_sp;
95  lldb::StackFrameSP frame_sp;
96 
97  return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp);
98 }
99 
100 lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
101  ConstString &object_name,
102  Status &err) {
103  err.Clear();
104 
105  if (!frame_sp) {
107  "Couldn't load '%s' because the context is incomplete",
108  object_name.AsCString());
109  return LLDB_INVALID_ADDRESS;
110  }
111 
112  lldb::VariableSP var_sp;
113  lldb::ValueObjectSP valobj_sp;
114 
115  valobj_sp = frame_sp->GetValueForVariableExpressionPath(
116  object_name.GetStringRef(), lldb::eNoDynamicValues,
121  var_sp, err);
122 
123  if (!err.Success() || !valobj_sp.get())
124  return LLDB_INVALID_ADDRESS;
125 
126  lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
127 
128  if (ret == LLDB_INVALID_ADDRESS) {
130  "Couldn't load '%s' because its value couldn't be evaluated",
131  object_name.AsCString());
132  return LLDB_INVALID_ADDRESS;
133  }
134 
135  return ret;
136 }
137 
140  const EvaluateExpressionOptions &options,
141  llvm::StringRef expr, llvm::StringRef prefix,
142  lldb::ValueObjectSP &result_valobj_sp, Status &error,
143  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  const char *fixed_text = user_expression_sp->GetFixedText();
258  if (fixed_text != nullptr)
259  fixed_expression->append(fixed_text);
260 
261  // If there is a fixed expression, try to parse it:
262  if (!parse_success) {
263  // Delete the expression that failed to parse before attempting to parse
264  // the next expression.
265  user_expression_sp.reset();
266 
267  execution_results = lldb::eExpressionParseError;
268  if (fixed_expression && !fixed_expression->empty() &&
269  options.GetAutoApplyFixIts()) {
270  const uint64_t max_fix_retries = options.GetRetriesWithFixIts();
271  for (uint64_t i = 0; i < max_fix_retries; ++i) {
272  // Try parsing the fixed expression.
273  lldb::UserExpressionSP fixed_expression_sp(
275  fixed_expression->c_str(), full_prefix, language, desired_type,
276  options, ctx_obj, error));
277  DiagnosticManager fixed_diagnostic_manager;
278  parse_success = fixed_expression_sp->Parse(
279  fixed_diagnostic_manager, exe_ctx, execution_policy,
280  keep_expression_in_memory, generate_debug_info);
281  if (parse_success) {
282  diagnostic_manager.Clear();
283  user_expression_sp = fixed_expression_sp;
284  break;
285  } else {
286  // The fixed expression also didn't parse. Let's check for any new
287  // Fix-Its we could try.
288  if (fixed_expression_sp->GetFixedText()) {
289  *fixed_expression = fixed_expression_sp->GetFixedText();
290  } else {
291  // Fixed expression didn't compile without a fixit, don't retry and
292  // don't tell the user about it.
293  fixed_expression->clear();
294  break;
295  }
296  }
297  }
298  }
299 
300  if (!parse_success) {
301  std::string msg;
302  {
303  llvm::raw_string_ostream os(msg);
304  os << "expression failed to parse:\n";
305  if (!diagnostic_manager.Diagnostics().empty())
306  os << diagnostic_manager.GetString();
307  else
308  os << "unknown error";
309  if (target->GetEnableNotifyAboutFixIts() && fixed_expression &&
310  !fixed_expression->empty())
311  os << "\nfixed expression suggested:\n " << *fixed_expression;
312  }
313  error.SetExpressionError(execution_results, msg.c_str());
314  }
315  }
316 
317  if (parse_success) {
318  lldb::ExpressionVariableSP expr_result;
319 
320  if (execution_policy == eExecutionPolicyNever &&
321  !user_expression_sp->CanInterpret()) {
322  LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but "
323  "is not constant ==");
324 
325  if (!diagnostic_manager.Diagnostics().size())
326  error.SetExpressionError(lldb::eExpressionSetupError,
327  "expression needed to run but couldn't");
328  } else if (execution_policy == eExecutionPolicyTopLevel) {
331  } else {
333  error.SetExpressionError(
335  "expression interrupted by callback before execution");
336  result_valobj_sp = ValueObjectConstResult::Create(
339  }
340 
341  diagnostic_manager.Clear();
342 
343  LLDB_LOG(log, "== [UserExpression::Evaluate] Executing expression ==");
344 
345  execution_results =
346  user_expression_sp->Execute(diagnostic_manager, exe_ctx, options,
347  user_expression_sp, expr_result);
348 
349  if (execution_results != lldb::eExpressionCompleted) {
350  LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed "
351  "abnormally ==");
352 
353  if (!diagnostic_manager.Diagnostics().size())
354  error.SetExpressionError(
355  execution_results, "expression failed to execute, unknown error");
356  else
357  error.SetExpressionError(execution_results,
358  diagnostic_manager.GetString().c_str());
359  } else {
360  if (expr_result) {
361  result_valobj_sp = expr_result->GetValueObject();
362  result_valobj_sp->SetPreferredDisplayLanguage(language);
363 
364  LLDB_LOG(log,
365  "== [UserExpression::Evaluate] Execution completed "
366  "normally with result {0} ==",
367  result_valobj_sp->GetValueAsCString());
368  } else {
369  LLDB_LOG(log, "== [UserExpression::Evaluate] Execution completed "
370  "normally with no result ==");
371 
373  }
374  }
375  }
376  }
377 
379  error.SetExpressionError(
381  "expression interrupted by callback after complete");
383  }
384 
385  if (result_valobj_sp.get() == nullptr) {
386  result_valobj_sp = ValueObjectConstResult::Create(
388  }
389 
390  return execution_results;
391 }
392 
395  ExecutionContext &exe_ctx,
396  const EvaluateExpressionOptions &options,
397  lldb::UserExpressionSP &shared_ptr_to_me,
398  lldb::ExpressionVariableSP &result_var) {
399  lldb::ExpressionResults expr_result = DoExecute(
400  diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var);
401  Target *target = exe_ctx.GetTargetPtr();
402  if (options.GetResultIsInternal() && result_var && target) {
403  if (auto *persistent_state =
405  persistent_state->RemovePersistentVariable(result_var);
406  }
407  return expr_result;
408 }
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:58
Block.h
lldb_private::UserExpression::m_address
Address m_address
The address the process is stopped in.
Definition: UserExpression.h:294
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:336
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:208
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:340
lldb_private::EvaluateExpressionOptions::DoesCoerceToId
bool DoesCoerceToId() const
Definition: Target.h:288
lldb_private::eExecutionPolicyNever
@ eExecutionPolicyNever
Definition: lldb-private-enumerations.h:146
lldb_private::EvaluateExpressionOptions::GetPrefix
const char * GetPrefix() const
Definition: Target.h:290
Module.h
lldb_private::EvaluateExpressionOptions
Definition: Target.h:258
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:139
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:403
IRInterpreter.h
lldb_private::StackFrame::eExpressionPathOptionsNoFragileObjcIvar
@ eExpressionPathOptionsNoFragileObjcIvar
Definition: StackFrame.h:45
lldb_private::Target
Definition: Target.h:450
lldb_private::Process::GetState
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1295
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:352
lldb_private::Process::CanJIT
bool CanJIT()
Determines whether executing JIT-compiled code in this process is possible.
Definition: Process.cpp:2330
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
LIBLLDB_LOG_EXPRESSIONS
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
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:288
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:256
StreamString.h
Type.h
lldb_private::ConstString
Definition: ConstString.h:40
lldb::eExpressionEvaluationComplete
@ eExpressionEvaluationComplete
Definition: lldb-enumerations.h:959
lldb_private::UserExpression::GetObjectPointer
static lldb::addr_t GetObjectPointer(lldb::StackFrameSP frame_sp, ConstString &object_name, Status &err)
Definition: UserExpression.cpp:100
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:956
IRExecutionUnit.h
HostInfo.h
lldb_private::Target::GetPersistentExpressionStateForLanguage
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
Definition: Target.cpp:2261
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::Address::CompareLoadAddress
static int CompareLoadAddress(const Address &lhs, const Address &rhs, Target *target)
Definition: Address.cpp:918
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:284
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::ExecutionContext::GetBestExecutionContextScope
ExecutionContextScope * GetBestExecutionContextScope() const
Definition: ExecutionContext.cpp:216
lldb_private::UserExpression::m_language
lldb::LanguageType m_language
The language to use when parsing (eLanguageTypeUnknown means use defaults)
Definition: UserExpression.h:301
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:394
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
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:242
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:2275
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:47
lldb_private::EvaluateExpressionOptions::GetExecutionPolicy
ExecutionPolicy GetExecutionPolicy() const
Definition: Target.h:278
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:4163
LIBLLDB_LOG_STEP
#define LIBLLDB_LOG_STEP
Definition: Logging.h:21
lldb_private::EvaluateExpressionOptions::GetResultIsInternal
bool GetResultIsInternal() const
Definition: Target.h:399
lldb_private::TargetProperties::GetEnableNotifyAboutFixIts
bool GetEnableNotifyAboutFixIts() const
Definition: Target.cpp:4091
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:168
ConstString.h
lldb_private::EvaluateExpressionOptions::InvokeCancelCallback
bool InvokeCancelCallback(lldb::ExpressionEvaluationPhase phase) const
Definition: Target.h:373
lldb_private::UserExpression::LockAndCheckContext
bool LockAndCheckContext(ExecutionContext &exe_ctx, lldb::TargetSP &target_sp, lldb::ProcessSP &process_sp, lldb::StackFrameSP &frame_sp)
Definition: UserExpression.cpp:67
lldb::eExpressionParseError
@ eExpressionParseError
Definition: lldb-enumerations.h:273
lldb_private::Log
Definition: Log.h:49
lldb_private::GetLogIfAnyCategoriesSet
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
SymbolVendor.h
lldb_private::EvaluateExpressionOptions::GetRetriesWithFixIts
uint64_t GetRetriesWithFixIts() const
Definition: Target.h:409
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::Expression
Definition: Expression.h:33
lldb::eExpressionEvaluationExecution
@ eExpressionEvaluationExecution
Definition: lldb-enumerations.h:958
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
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:200
ExecutionContext.h
lldb_private::UserExpression::MatchesContext
bool MatchesContext(ExecutionContext &exe_ctx)
Definition: UserExpression.cpp:92