55#include "clang/AST/DeclCXX.h"
56#include "clang/AST/DeclObjC.h"
58#include "llvm/ADT/ScopeExit.h"
71 m_type_system_helper(*m_target_wp.lock(), options.GetExecutionPolicy() ==
73 m_result_delegate(exe_scope.CalculateTarget()), m_ctx_obj(ctx_obj) {
94 LLDB_LOGF(log,
"ClangUserExpression::ScanContext()");
99 LLDB_LOGF(log,
" [CUE::SC] Settings inhibit C++ and Objective-C");
104 if (frame ==
nullptr) {
105 LLDB_LOGF(log,
" [CUE::SC] Null stack frame");
110 lldb::eSymbolContextBlock);
113 LLDB_LOGF(log,
" [CUE::SC] Null function");
120 if (!function_block) {
121 LLDB_LOGF(log,
" [CUE::SC] Null function block");
128 LLDB_LOGF(log,
" [CUE::SC] Null decl context");
152 }
else if (clang::CXXMethodDecl *method_decl =
159 const char *thisErrorString =
"Stopped in a C++ method, but 'this' "
160 "isn't available; pretending we are in a "
163 if (!variable_list_sp) {
169 variable_list_sp->FindVariable(
ConstString(
"this")));
171 if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
172 !this_var_sp->LocationIsValidForFrame(frame)) {
181 }
else if (clang::ObjCMethodDecl *method_decl =
189 const char *selfErrorString =
"Stopped in an Objective-C method, but "
190 "'self' isn't available; pretending we "
191 "are in a generic context";
193 if (!variable_list_sp) {
199 variable_list_sp->FindVariable(
ConstString(
"self"));
201 if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
202 !self_variable_sp->LocationIsValidForFrame(frame)) {
211 if (!method_decl->isInstanceMethod())
214 }
else if (clang::FunctionDecl *function_decl =
231 const char *thisErrorString =
"Stopped in a context claiming to "
232 "capture a C++ object pointer, but "
233 "'this' isn't available; pretending we "
234 "are in a generic context";
236 if (!variable_list_sp) {
242 variable_list_sp->FindVariable(
ConstString(
"this")));
244 if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
245 !this_var_sp->LocationIsValidForFrame(frame)) {
258 const char *selfErrorString =
259 "Stopped in a context claiming to capture an Objective-C object "
260 "pointer, but 'self' isn't available; pretending we are in a "
263 if (!variable_list_sp) {
269 variable_list_sp->FindVariable(
ConstString(
"self"));
271 if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
272 !self_variable_sp->LocationIsValidForFrame(frame)) {
277 Type *self_type = self_variable_sp->GetType();
286 if (!self_clang_type) {
315 const std::string from =
"(int)[";
316 const std::string to =
"(int)(long long)[";
320 while ((offset = expr.find(from)) != expr.npos)
321 expr.replace(offset, from.size(), to);
328 target->GetPersistentExpressionStateForLanguage(
330 m_clang_state = llvm::cast<ClangPersistentVariables>(persistent_state);
335 "couldn't start parsing (no persistent data)");
340 "error: couldn't start parsing (no target)");
351 auto *persistent_state = llvm::cast<ClangPersistentVariables>(
353 if (!persistent_state)
356 std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
357 persistent_state->GetClangModulesDeclVendor();
377 persistent_state->GetHandLoadedClangModules();
378 if (decl_vendor->AddModulesForCompileUnit(*sc.
comp_unit, modules_for_macros,
383 if (!error_stream.
Empty()) {
393 "Unknown error while loading modules needed for "
394 "current compilation unit.");
399 "Top level expressions aren't wrapped.");
402 return Kind::CppMemberFunction;
405 return Kind::ObjCStaticMethod;
406 return Kind::ObjCInstanceMethod;
410 return Kind::Function;
415 std::vector<std::string> modules_to_import,
bool for_completion) {
426 for_completion, modules_to_import)) {
428 "couldn't construct expression body");
434 std::size_t original_start;
435 std::size_t original_end;
460 LLDB_LOG(log,
"[C++ module config] {0}", msg);
495 llvm::DenseSet<SymbolFile *> visited_symbol_files;
497 visited_symbol_files, [&files](
Module &module) {
501 for (
const FileSpec &f : support_files) {
508 LLDB_LOG(log,
"[C++ module config] Found {0} support files to analyze",
512 LLDB_LOGV(log,
"[C++ module config] Analyzing support file: {0}",
524 bool for_completion) {
558 bool keep_result_in_memory,
bool generate_debug_info) {
563 auto on_exit = llvm::make_scope_exit([
this]() {
ResetDeclMap(); });
568 "current process state is unsuitable for expression parsing");
576 m_parser = std::make_unique<ClangExpressionParser>(
579 unsigned num_errors =
m_parser->Parse(diagnostic_manager);
585 if (
m_parser->RewriteExpression(diagnostic_manager)) {
594 m_fixed_text.substr(fixed_start, fixed_end - fixed_start);
611 const char *error_cstr = jit_error.
AsCString();
612 if (error_cstr && error_cstr[0])
616 "expression can't be interpreted or run");
630 LLDB_LOG(log,
"List of imported modules in expression: {0}",
633 LLDB_LOG(log,
"List of include directories gathered for modules: {0}",
648 bool keep_result_in_memory,
649 bool generate_debug_info) {
678 bool parse_success =
TryParse(diagnostic_manager, exe_scope, exe_ctx,
679 execution_policy, keep_result_in_memory,
680 generate_debug_info);
698 parse_success =
TryParse(retry_manager, exe_scope, exe_ctx,
699 execution_policy, keep_result_in_memory,
700 generate_debug_info);
703 diagnostic_manager = std::move(retry_manager);
710 Status static_init_error =
713 if (!static_init_error.
Success()) {
714 const char *error_cstr = static_init_error.
AsCString();
715 if (error_cstr && error_cstr[0])
721 "couldn't run static initializers\n");
727 bool register_execution_unit =
false;
730 register_execution_unit =
true;
738 register_execution_unit =
true;
741 if (register_execution_unit) {
742 if (
auto *persistent_state =
749 if (generate_debug_info) {
756 jit_module_sp->SetFileSpecAndObjectName(jit_file,
ConstString());
785 unsigned &line,
unsigned &column) {
790 assert(abs_pos <= code.size() &&
"Absolute position outside code string?");
793 for (std::size_t i = 0; i < abs_pos; ++i) {
797 if (code[i] ==
'\n') {
808 unsigned complete_pos) {
829 auto on_exit = llvm::make_scope_exit([
this]() {
ResetDeclMap(); });
834 "current process state is unsuitable for expression parsing");
859 unsigned user_expr_line, user_expr_column;
862 user_expr_line, user_expr_column);
868 const unsigned completion_column = user_expr_column + complete_pos;
869 parser.
Complete(request, user_expr_line, completion_column, complete_pos);
882 if (
auto thisChildSP = valobj_sp->GetChildMemberWithName(
"this")) {
883 valobj_sp = thisChildSP;
886 if (!err.
Success() || !valobj_sp.get())
893 "Couldn't load '{0}' because its value couldn't be evaluated",
902 std::vector<lldb::addr_t> &args,
916 "need object pointer but don't know the language");
920 static constexpr llvm::StringLiteral g_cplusplus_object_name(
"this");
921 static constexpr llvm::StringLiteral g_objc_object_name(
"self");
922 llvm::StringRef object_name =
943 if (!object_ptr_error.
Success()) {
945 "warning: `{0}' is not accessible (substituting 0). {1}\n",
946 object_name, object_ptr_error.
AsCString());
951 static constexpr llvm::StringLiteral cmd_name(
"_cmd");
955 if (!object_ptr_error.
Success()) {
956 diagnostic_manager.
Printf(
958 "couldn't get cmd pointer (substituting NULL): %s",
964 args.push_back(object_ptr);
967 args.push_back(cmd_ptr);
969 args.push_back(struct_address);
971 args.push_back(struct_address);
986 bool keep_result_in_memory,
988 std::shared_ptr<ClangASTImporter> ast_importer;
989 auto *state = exe_ctx.
GetTargetSP()->GetPersistentExpressionStateForLanguage(
992 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
993 ast_importer = persistent_vars->GetClangASTImporter();
996 keep_result_in_memory, &delegate, exe_ctx.
GetTargetSP(), ast_importer,
1002 clang::ASTConsumer *passthrough) {
1003 m_result_synthesizer_up = std::make_unique<ASTResultSynthesizer>(
1004 passthrough, m_top_level,
m_target);
1006 return m_result_synthesizer_up.get();
1010 if (m_result_synthesizer_up) {
1011 m_result_synthesizer_up->CommitPersistentDecls();
1016 return m_persistent_state->GetNextPersistentVariableName(
false);
1021 m_variable = variable;
1026 m_persistent_state = persistent_state;
static bool shouldRetryWithCppModule(Target &target, ExecutionPolicy exe_policy)
CppModuleConfiguration GetModuleConfig(lldb::LanguageType language, ExecutionContext &exe_ctx)
static CppModuleConfiguration LogConfigError(const std::string &msg)
Utility method that puts a message into the expression log and returns an invalid module configuratio...
static void AbsPosToLineColumnPos(size_t abs_pos, llvm::StringRef code, unsigned &line, unsigned &column)
Converts an absolute position inside a given code string into a column/line pair.
static void SetupDeclVendor(ExecutionContext &exe_ctx, Target *target, DiagnosticManager &diagnostic_manager)
static bool SupportsCxxModuleImport(lldb::LanguageType language)
static void ApplyObjcCastHack(std::string &expr)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
#define LLDB_LOGV(log,...)
llvm::Triple & GetTriple()
Architecture triple accessor.
A class that describes a single lexical block.
lldb::VariableListSP GetBlockVariableList(bool can_create)
Get the variable list for this block only.
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
CompilerDeclContext GetDeclContext()
void SetLookupsEnabled(bool lookups_enabled)
bool WillParse(ExecutionContext &exe_ctx, Materializer *materializer)
Enable the state needed for parsing and IR transformation.
"lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of Clang that can parse expression...
bool Complete(CompletionRequest &request, unsigned line, unsigned pos, unsigned typed_pos) override
Attempts to find possible command line completions for the given expression.
WrapKind
The possible ways an expression can be wrapped.
static ClangExpressionSourceCode * CreateWrapped(llvm::StringRef filename, llvm::StringRef prefix, llvm::StringRef body, WrapKind wrap_kind)
std::vector< ModuleID > ModuleVector
std::string GetNextExprFileName()
Returns the next file name that should be used for user expressions.
void CommitPersistentDecls() override
clang::ASTConsumer * ASTTransformer(clang::ASTConsumer *passthrough) override
Return the object that the parser should allow to access ASTs.
std::unique_ptr< ClangExpressionDeclMap > m_expr_decl_map_up
void RegisterPersistentState(PersistentExpressionState *persistent_state)
lldb::ExpressionVariableSP & GetVariable()
void DidDematerialize(lldb::ExpressionVariableSP &variable) override
ConstString GetName() override
bool m_enforce_valid_object
True if the expression parser should enforce the presence of a valid class pointer in order to genera...
std::string m_filename
File name used for the expression.
lldb::ExpressionVariableSP GetResultAfterDematerialization(ExecutionContextScope *exe_scope) override
bool m_in_objectivec_method
True if the expression is compiled as an Objective-C method (true if it was parsed when exe_ctx was i...
void CreateSourceCode(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, std::vector< std::string > modules_to_import, bool for_completion)
bool Complete(ExecutionContext &exe_ctx, CompletionRequest &request, unsigned complete_pos) override
Attempts to find possible command line completions for the given (possible incomplete) user expressio...
ClangExpressionSourceCode::WrapKind GetWrapKind() const
Defines how the current expression should be wrapped.
bool TryParse(DiagnosticManager &diagnostic_manager, ExecutionContextScope *exe_scope, ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory, bool generate_debug_info)
Populate m_in_cplusplus_method and m_in_objectivec_method based on the environment.
std::unique_ptr< ClangExpressionParser > m_parser
The parser instance we used to parse the expression.
void SetupCppModuleImports(ExecutionContext &exe_ctx)
~ClangUserExpression() override
bool PrepareForParsing(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, bool for_completion)
bool m_needs_object_ptr
True if "this" or "self" must be looked up and passed in.
ClangExpressionDeclMap * DeclMap()
bool SetupPersistentState(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx)
bool m_in_static_method
True if the expression is compiled as a static (or class) method (currently true if it was parsed whe...
bool Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory, bool generate_debug_info) override
Parse the expression.
std::optional< size_t > m_user_expression_start_pos
The absolute character position in the transformed source code where the user code (as typed by the u...
bool AddArguments(ExecutionContext &exe_ctx, std::vector< lldb::addr_t > &args, lldb::addr_t struct_address, DiagnosticManager &diagnostic_manager) override
lldb::addr_t GetCppObjectPointer(lldb::StackFrameSP frame, llvm::StringRef object_name, Status &err)
std::unique_ptr< ClangExpressionSourceCode > m_source_code
ResultDelegate m_result_delegate
std::vector< std::string > m_imported_cpp_modules
A list of module names that should be imported when parsing.
ClangPersistentVariables * m_clang_state
ClangUserExpression(ExecutionContextScope &exe_scope, llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj)
Constructor.
void ScanContext(ExecutionContext &exe_ctx, lldb_private::Status &err) override
bool m_in_cplusplus_method
True if the expression is compiled as a C++ member function (true if it was parsed when exe_ctx was i...
std::vector< std::string > m_include_directories
The include directories that should be used when parsing the expression.
ValueObject * m_ctx_obj
The object (if any) in which context the expression is evaluated.
virtual bool ForEachExternalModule(llvm::DenseSet< lldb_private::SymbolFile * > &visited_symbol_files, llvm::function_ref< bool(Module &)> lambda)
Apply a lambda to each external lldb::Module referenced by this compilation unit.
const FileSpecList & GetSupportFiles()
Get the compile unit's support file list.
Represents a generic declaration context in a program.
Generic representation of a type in a programming language.
"lldb/Utility/ArgCompletionRequest.h"
A uniqued constant string class.
A Clang configuration when importing C++ modules.
llvm::ArrayRef< std::string > GetIncludeDirs() const
Returns a list of include directories that should be used when using this configuration (e....
llvm::ArrayRef< std::string > GetImportedModules() const
Returns a list of (top level) modules that should be imported when using this configuration (e....
lldb::StreamSP GetAsyncOutputStream()
size_t Printf(DiagnosticSeverity severity, const char *format,...) __attribute__((format(printf
size_t void PutString(DiagnosticSeverity severity, llvm::StringRef str)
const std::string & GetFixedExpression()
ExecutionPolicy GetExecutionPolicy() const
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
const lldb::StackFrameSP & GetFrameSP() const
Get accessor to get the frame shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
Target & GetTargetRef() const
Returns a reference to the target object.
Process * GetProcessPtr() const
Returns a pointer to the process object.
lldb::addr_t m_jit_end_addr
The address of the JITted function within the JIT allocation.
lldb::ProcessWP m_jit_process_wp
Expression's always have to have a target...
lldb::addr_t m_jit_start_addr
An expression might have a process, but it doesn't need to (e.g.
size_t GetSize() const
Get the number of files in the file list.
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
void SetFilename(ConstString filename)
Filename string set accessor.
"lldb/Expression/LLVMUserExpression.h" Encapsulates a one-time expression for use in lldb.
std::string m_transformed_text
The text of the expression, as send to the parser.
bool m_can_interpret
True if the expression could be evaluated statically; false otherwise.
Materializer * GetMaterializer() override
Return the Materializer that the parser should use when registering external values.
std::unique_ptr< Materializer > m_materializer_up
The materializer to use when running the expression.
bool m_allow_cxx
True if the language allows C++.
Target * m_target
The target for storing persistent data like types and variables.
lldb::ModuleWP m_jit_module_wp
std::shared_ptr< IRExecutionUnit > m_execution_unit_sp
The execution unit the expression is stored in.
bool m_allow_objc
True if the language allows Objective-C.
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
A class that describes an executable image and its associated object and symbol files.
lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx)
size_t GetNumCompileUnits()
Get the number of compile units for this module.
A plug-in interface definition class for debugging a process.
This base class provides an interface to stack frames.
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Block * GetFrameBlock()
Get the current lexical scope block for this StackFrame, if possible.
void SetErrorStringWithFormatv(const char *format, Args &&... args)
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
bool Success() const
Test for success condition.
llvm::StringRef GetString() const
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
Block * GetFunctionBlock()
Find a block that defines the function represented by this symbol context.
CompileUnit * comp_unit
The CompileUnit for a given query.
ImportStdModule GetImportStdModule() const
bool GetEnableAutoImportClangModules() const
PersistentExpressionState * GetPersistentExpressionStateForLanguage(lldb::LanguageType language)
const ModuleList & GetImages() const
Get accessor for the images for this process.
const ArchSpec & GetArchitecture() const
static clang::CXXMethodDecl * DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc)
static clang::ObjCMethodDecl * DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc)
static clang::FunctionDecl * DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc)
static bool IsObjCClassType(const CompilerType &type)
static ClangASTMetadata * DeclContextGetMetaData(const CompilerDeclContext &dc, const clang::Decl *object)
static bool IsObjCObjectPointerType(const CompilerType &type, CompilerType *target_type=nullptr)
CompilerType GetForwardCompilerType()
static lldb::ValueObjectSP GetObjectPointerValueObject(lldb::StackFrameSP frame, llvm::StringRef object_name, Status &err)
Return ValueObject for a given variable name in the current stack frame.
std::string m_fixed_text
The text of the expression with fix-its applied.
void InstallContext(ExecutionContext &exe_ctx)
Populate m_in_cplusplus_method and m_in_objectivec_method based on the environment.
std::string m_expr_prefix
The text of the translation-level definitions, as provided by the user.
const char * FunctionName() override
Return the function name that should be used for executing the expression.
std::string m_expr_text
The text of the expression, as typed by the user.
EvaluateExpressionOptions m_options
Additional options provided by the user.
static lldb::addr_t GetObjectPointer(lldb::StackFrameSP frame_sp, llvm::StringRef object_name, Status &err)
lldb::LanguageType m_language
The language to use when parsing (eLanguageTypeUnknown means use defaults)
lldb::LanguageType GetObjectRuntimeLanguage()
virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address=true, AddressType *address_type=nullptr)
#define LLDB_INVALID_ADDRESS
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
@ eDiagnosticSeverityError
@ eDiagnosticSeverityWarning
@ eDiagnosticSeverityRemark
ExecutionPolicy
Expression execution policies.
@ eExecutionPolicyTopLevel
@ eImportStdModuleFallback
@ eAddressTypeLoad
Address is an address as in the current target inferior process.
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
std::shared_ptr< lldb_private::ExpressionVariable > ExpressionVariableSP
LanguageType
Programming language type.
@ eLanguageTypeC_plus_plus_14
ISO C++:2014.
@ eLanguageTypeC11
ISO C:2011.
@ eLanguageTypeC99
ISO C:1999.
@ eLanguageTypeC_plus_plus_03
ISO C++:2003.
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eLanguageTypeC_plus_plus_11
ISO C++:2011.
@ eLanguageTypeC89
ISO C:1989.
@ eLanguageTypeC
Non-standardized C, such as K&R.
@ eLanguageTypeObjC
Objective-C.
@ eLanguageTypeC_plus_plus
ISO C++:1998.
std::shared_ptr< lldb_private::VariableList > VariableListSP
std::weak_ptr< lldb_private::Process > ProcessWP
std::shared_ptr< lldb_private::Variable > VariableSP
std::shared_ptr< lldb_private::Module > ModuleSP