1//===-- ClangUserExpression.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 "ClangUserExpression.h" 17 18#include "ASTResultSynthesizer.h" 19#include "ClangASTMetadata.h" 20#include "ClangDiagnostic.h" 21#include "ClangExpressionDeclMap.h" 22#include "ClangExpressionParser.h" 23#include "ClangModulesDeclVendor.h" 24#include "ClangPersistentVariables.h" 25#include "CppModuleConfiguration.h" 26 27#include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 28#include "lldb/Core/Debugger.h" 29#include "lldb/Core/Module.h" 30#include "lldb/Core/ValueObjectConstResult.h" 31#include "lldb/Expression/ExpressionSourceCode.h" 32#include "lldb/Expression/IRExecutionUnit.h" 33#include "lldb/Expression/IRInterpreter.h" 34#include "lldb/Expression/Materializer.h" 35#include "lldb/Host/HostInfo.h" 36#include "lldb/Symbol/Block.h" 37#include "lldb/Symbol/CompileUnit.h" 38#include "lldb/Symbol/Function.h" 39#include "lldb/Symbol/ObjectFile.h" 40#include "lldb/Symbol/SymbolFile.h" 41#include "lldb/Symbol/SymbolVendor.h" 42#include "lldb/Symbol/Type.h" 43#include "lldb/Symbol/VariableList.h" 44#include "lldb/Target/ExecutionContext.h" 45#include "lldb/Target/Process.h" 46#include "lldb/Target/StackFrame.h" 47#include "lldb/Target/Target.h" 48#include "lldb/Target/ThreadPlan.h" 49#include "lldb/Target/ThreadPlanCallUserExpression.h" 50#include "lldb/Utility/ConstString.h" 51#include "lldb/Utility/LLDBLog.h" 52#include "lldb/Utility/Log.h" 53#include "lldb/Utility/StreamString.h" 54 55#include "clang/AST/DeclCXX.h" 56#include "clang/AST/DeclObjC.h" 57 58#include "llvm/ADT/ScopeExit.h" 59 60using namespace lldb_private; 61 62char ClangUserExpression::ID; 63 64ClangUserExpression::ClangUserExpression( 65 ExecutionContextScope &exe_scope, llvm::StringRef expr, 66 llvm::StringRef prefix, lldb::LanguageType language, 67 ResultType desired_type, const EvaluateExpressionOptions &options, 68 ValueObject *ctx_obj) 69 : LLVMUserExpression(exe_scope, expr, prefix, language, desired_type, 70 options), 71 m_type_system_helper(*m_target_wp.lock(), options.GetExecutionPolicy() == 72 eExecutionPolicyTopLevel), 73 m_result_delegate(exe_scope.CalculateTarget()), m_ctx_obj(ctx_obj) { 74 switch (m_language) { 75 case lldb::eLanguageTypeC_plus_plus: 76 m_allow_cxx = true; 77 break; 78 case lldb::eLanguageTypeObjC: 79 m_allow_objc = true; 80 break; 81 case lldb::eLanguageTypeObjC_plus_plus: 82 default: 83 m_allow_cxx = true; 84 m_allow_objc = true; 85 break; 86 } 87} 88 89ClangUserExpression::~ClangUserExpression() = default; 90 91void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) { 92 Log *log = GetLog(LLDBLog::Expressions); 93 94 LLDB_LOGF(log, "ClangUserExpression::ScanContext()"); 95 96 m_target = exe_ctx.GetTargetPtr(); 97 98 if (!(m_allow_cxx || m_allow_objc)) { 99 LLDB_LOGF(log, " [CUE::SC] Settings inhibit C++ and Objective-C"); 100 return; 101 } 102 103 StackFrame *frame = exe_ctx.GetFramePtr(); 104 if (frame == nullptr) { 105 LLDB_LOGF(log, " [CUE::SC] Null stack frame"); 106 return; 107 } 108 109 SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction | 110 lldb::eSymbolContextBlock); 111 112 if (!sym_ctx.function) { 113 LLDB_LOGF(log, " [CUE::SC] Null function"); 114 return; 115 } 116 117 // Find the block that defines the function represented by "sym_ctx" 118 Block *function_block = sym_ctx.GetFunctionBlock(); 119 120 if (!function_block) { 121 LLDB_LOGF(log, " [CUE::SC] Null function block"); 122 return; 123 } 124 125 CompilerDeclContext decl_context = function_block->GetDeclContext(); 126 127 if (!decl_context) { 128 LLDB_LOGF(log, " [CUE::SC] Null decl context"); 129 return; 130 } 131 132 if (m_ctx_obj) { 133 switch (m_ctx_obj->GetObjectRuntimeLanguage()) { 134 case lldb::eLanguageTypeC: 135 case lldb::eLanguageTypeC89: 136 case lldb::eLanguageTypeC99: 137 case lldb::eLanguageTypeC11: 138 case lldb::eLanguageTypeC_plus_plus: 139 case lldb::eLanguageTypeC_plus_plus_03: 140 case lldb::eLanguageTypeC_plus_plus_11: 141 case lldb::eLanguageTypeC_plus_plus_14: 142 m_in_cplusplus_method = true; 143 break; 144 case lldb::eLanguageTypeObjC: 145 case lldb::eLanguageTypeObjC_plus_plus: 146 m_in_objectivec_method = true; 147 break; 148 default: 149 break; 150 } 151 m_needs_object_ptr = true; 152 } else if (clang::CXXMethodDecl *method_decl = 153 TypeSystemClang::DeclContextGetAsCXXMethodDecl(decl_context)) { 154 if (m_allow_cxx && method_decl->isInstance()) { 155 if (m_enforce_valid_object) { 156 lldb::VariableListSP variable_list_sp( 157 function_block->GetBlockVariableList(true)); 158 159 const char *thisErrorString = "Stopped in a C++ method, but 'this' " 160 "isn't available; pretending we are in a " 161 "generic context"; 162 163 if (!variable_list_sp) { 164 err.SetErrorString(thisErrorString); 165 return; 166 } 167 168 lldb::VariableSP this_var_sp( 169 variable_list_sp->FindVariable(ConstString("this"))); 170 171 if (!this_var_sp || !this_var_sp->IsInScope(frame) || 172 !this_var_sp->LocationIsValidForFrame(frame)) { 173 err.SetErrorString(thisErrorString); 174 return; 175 } 176 } 177 178 m_in_cplusplus_method = true; 179 m_needs_object_ptr = true; 180 } 181 } else if (clang::ObjCMethodDecl *method_decl = 182 TypeSystemClang::DeclContextGetAsObjCMethodDecl( 183 decl_context)) { 184 if (m_allow_objc) { 185 if (m_enforce_valid_object) { 186 lldb::VariableListSP variable_list_sp( 187 function_block->GetBlockVariableList(true)); 188 189 const char *selfErrorString = "Stopped in an Objective-C method, but " 190 "'self' isn't available; pretending we " 191 "are in a generic context"; 192 193 if (!variable_list_sp) { 194 err.SetErrorString(selfErrorString); 195 return; 196 } 197 198 lldb::VariableSP self_variable_sp = 199 variable_list_sp->FindVariable(ConstString("self")); 200 201 if (!self_variable_sp || !self_variable_sp->IsInScope(frame) || 202 !self_variable_sp->LocationIsValidForFrame(frame)) { 203 err.SetErrorString(selfErrorString); 204 return; 205 } 206 } 207 208 m_in_objectivec_method = true; 209 m_needs_object_ptr = true; 210 211 if (!method_decl->isInstanceMethod()) 212 m_in_static_method = true; 213 } 214 } else if (clang::FunctionDecl *function_decl = 215 TypeSystemClang::DeclContextGetAsFunctionDecl(decl_context)) { 216 // We might also have a function that said in the debug information that it 217 // captured an object pointer. The best way to deal with getting to the 218 // ivars at present is by pretending that this is a method of a class in 219 // whatever runtime the debug info says the object pointer belongs to. Do 220 // that here. 221 222 ClangASTMetadata *metadata = 223 TypeSystemClang::DeclContextGetMetaData(decl_context, function_decl); 224 if (metadata && metadata->HasObjectPtr()) { 225 lldb::LanguageType language = metadata->GetObjectPtrLanguage(); 226 if (language == lldb::eLanguageTypeC_plus_plus) { 227 if (m_enforce_valid_object) { 228 lldb::VariableListSP variable_list_sp( 229 function_block->GetBlockVariableList(true)); 230 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"; 235 236 if (!variable_list_sp) { 237 err.SetErrorString(thisErrorString); 238 return; 239 } 240 241 lldb::VariableSP this_var_sp( 242 variable_list_sp->FindVariable(ConstString("this"))); 243 244 if (!this_var_sp || !this_var_sp->IsInScope(frame) || 245 !this_var_sp->LocationIsValidForFrame(frame)) { 246 err.SetErrorString(thisErrorString); 247 return; 248 } 249 } 250 251 m_in_cplusplus_method = true; 252 m_needs_object_ptr = true; 253 } else if (language == lldb::eLanguageTypeObjC) { 254 if (m_enforce_valid_object) { 255 lldb::VariableListSP variable_list_sp( 256 function_block->GetBlockVariableList(true)); 257 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 " 261 "generic context"; 262 263 if (!variable_list_sp) { 264 err.SetErrorString(selfErrorString); 265 return; 266 } 267 268 lldb::VariableSP self_variable_sp = 269 variable_list_sp->FindVariable(ConstString("self")); 270 271 if (!self_variable_sp || !self_variable_sp->IsInScope(frame) || 272 !self_variable_sp->LocationIsValidForFrame(frame)) { 273 err.SetErrorString(selfErrorString); 274 return; 275 } 276 277 Type *self_type = self_variable_sp->GetType(); 278 279 if (!self_type) { 280 err.SetErrorString(selfErrorString); 281 return; 282 } 283 284 CompilerType self_clang_type = self_type->GetForwardCompilerType(); 285 286 if (!self_clang_type) { 287 err.SetErrorString(selfErrorString); 288 return; 289 } 290 291 if (TypeSystemClang::IsObjCClassType(self_clang_type)) { 292 return; 293 } else if (TypeSystemClang::IsObjCObjectPointerType( 294 self_clang_type)) { 295 m_in_objectivec_method = true; 296 m_needs_object_ptr = true; 297 } else { 298 err.SetErrorString(selfErrorString); 299 return; 300 } 301 } else { 302 m_in_objectivec_method = true; 303 m_needs_object_ptr = true; 304 } 305 } 306 } 307 } 308} 309 310// This is a really nasty hack, meant to fix Objective-C expressions of the 311// form (int)[myArray count]. Right now, because the type information for 312// count is not available, [myArray count] returns id, which can't be directly 313// cast to int without causing a clang error. 314static void ApplyObjcCastHack(std::string &expr) { 315 const std::string from = "(int)["; 316 const std::string to = "(int)(long long)["; 317 318 size_t offset; 319 320 while ((offset = expr.find(from)) != expr.npos) 321 expr.replace(offset, from.size(), to); 322} 323 324bool ClangUserExpression::SetupPersistentState(DiagnosticManager &diagnostic_manager, 325 ExecutionContext &exe_ctx) { 326 if (Target *target = exe_ctx.GetTargetPtr()) { 327 if (PersistentExpressionState *persistent_state = 328 target->GetPersistentExpressionStateForLanguage( 329 lldb::eLanguageTypeC)) { 330 m_clang_state = llvm::cast<ClangPersistentVariables>(persistent_state); 331 m_result_delegate.RegisterPersistentState(persistent_state); 332 } else { 333 diagnostic_manager.PutString( 334 eDiagnosticSeverityError, 335 "couldn't start parsing (no persistent data)"); 336 return false; 337 } 338 } else { 339 diagnostic_manager.PutString(eDiagnosticSeverityError, 340 "error: couldn't start parsing (no target)"); 341 return false; 342 } 343 return true; 344} 345 346static void SetupDeclVendor(ExecutionContext &exe_ctx, Target *target, 347 DiagnosticManager &diagnostic_manager) { 348 if (!target->GetEnableAutoImportClangModules()) 349 return; 350 351 auto *persistent_state = llvm::cast<ClangPersistentVariables>( 352 target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)); 353 if (!persistent_state) 354 return; 355 356 std::shared_ptr<ClangModulesDeclVendor> decl_vendor = 357 persistent_state->GetClangModulesDeclVendor(); 358 if (!decl_vendor) 359 return; 360 361 StackFrame *frame = exe_ctx.GetFramePtr(); 362 if (!frame) 363 return; 364 365 Block *block = frame->GetFrameBlock(); 366 if (!block) 367 return; 368 SymbolContext sc; 369 370 block->CalculateSymbolContext(&sc); 371 372 if (!sc.comp_unit) 373 return; 374 StreamString error_stream; 375 376 ClangModulesDeclVendor::ModuleVector modules_for_macros = 377 persistent_state->GetHandLoadedClangModules(); 378 if (decl_vendor->AddModulesForCompileUnit(*sc.comp_unit, modules_for_macros, 379 error_stream)) 380 return; 381 382 // Failed to load some modules, so emit the error stream as a diagnostic. 383 if (!error_stream.Empty()) { 384 // The error stream already contains several Clang diagnostics that might 385 // be either errors or warnings, so just print them all as one remark 386 // diagnostic to prevent that the message starts with "error: error:". 387 diagnostic_manager.PutString(eDiagnosticSeverityRemark, 388 error_stream.GetString()); 389 return; 390 } 391 392 diagnostic_manager.PutString(eDiagnosticSeverityError, 393 "Unknown error while loading modules needed for " 394 "current compilation unit."); 395} 396 397ClangExpressionSourceCode::WrapKind ClangUserExpression::GetWrapKind() const { 398 assert(m_options.GetExecutionPolicy() != eExecutionPolicyTopLevel && 399 "Top level expressions aren't wrapped."); 400 using Kind = ClangExpressionSourceCode::WrapKind; 401 if (m_in_cplusplus_method) 402 return Kind::CppMemberFunction; 403 else if (m_in_objectivec_method) { 404 if (m_in_static_method) 405 return Kind::ObjCStaticMethod; 406 return Kind::ObjCInstanceMethod; 407 } 408 // Not in any kind of 'special' function, so just wrap it in a normal C 409 // function. 410 return Kind::Function; 411} 412 413void ClangUserExpression::CreateSourceCode( 414 DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, 415 std::vector<std::string> modules_to_import, bool for_completion) { 416 417 std::string prefix = m_expr_prefix; 418 419 if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) { 420 m_transformed_text = m_expr_text; 421 } else { 422 m_source_code.reset(ClangExpressionSourceCode::CreateWrapped( 423 m_filename, prefix, m_expr_text, GetWrapKind())); 424 425 if (!m_source_code->GetText(m_transformed_text, exe_ctx, !m_ctx_obj, 426 for_completion, modules_to_import)) { 427 diagnostic_manager.PutString(eDiagnosticSeverityError, 428 "couldn't construct expression body"); 429 return; 430 } 431 432 // Find and store the start position of the original code inside the 433 // transformed code. We need this later for the code completion. 434 std::size_t original_start; 435 std::size_t original_end; 436 bool found_bounds = m_source_code->GetOriginalBodyBounds( 437 m_transformed_text, original_start, original_end); 438 if (found_bounds) 439 m_user_expression_start_pos = original_start; 440 } 441} 442 443static bool SupportsCxxModuleImport(lldb::LanguageType language) { 444 switch (language) { 445 case lldb::eLanguageTypeC_plus_plus: 446 case lldb::eLanguageTypeC_plus_plus_03: 447 case lldb::eLanguageTypeC_plus_plus_11: 448 case lldb::eLanguageTypeC_plus_plus_14: 449 case lldb::eLanguageTypeObjC_plus_plus: 450 return true; 451 default: 452 return false; 453 } 454} 455 456/// Utility method that puts a message into the expression log and 457/// returns an invalid module configuration. 458static CppModuleConfiguration LogConfigError(const std::string &msg) { 459 Log *log = GetLog(LLDBLog::Expressions); 460 LLDB_LOG(log, "[C++ module config] {0}", msg); 461 return CppModuleConfiguration(); 462} 463 464CppModuleConfiguration GetModuleConfig(lldb::LanguageType language, 465 ExecutionContext &exe_ctx) { 466 Log *log = GetLog(LLDBLog::Expressions); 467 468 // Don't do anything if this is not a C++ module configuration. 469 if (!SupportsCxxModuleImport(language)) 470 return LogConfigError("Language doesn't support C++ modules"); 471 472 Target *target = exe_ctx.GetTargetPtr(); 473 if (!target) 474 return LogConfigError("No target"); 475 476 StackFrame *frame = exe_ctx.GetFramePtr(); 477 if (!frame) 478 return LogConfigError("No frame"); 479 480 Block *block = frame->GetFrameBlock(); 481 if (!block) 482 return LogConfigError("No block"); 483 484 SymbolContext sc; 485 block->CalculateSymbolContext(&sc); 486 if (!sc.comp_unit) 487 return LogConfigError("Couldn't calculate symbol context"); 488 489 // Build a list of files we need to analyze to build the configuration. 490 FileSpecList files; 491 for (auto &f : sc.comp_unit->GetSupportFiles()) 492 files.AppendIfUnique(f->Materialize()); 493 // We also need to look at external modules in the case of -gmodules as they 494 // contain the support files for libc++ and the C library. 495 llvm::DenseSet<SymbolFile *> visited_symbol_files; 496 sc.comp_unit->ForEachExternalModule( 497 visited_symbol_files, [&files](Module &module) { 498 for (std::size_t i = 0; i < module.GetNumCompileUnits(); ++i) { 499 const SupportFileList &support_files = 500 module.GetCompileUnitAtIndex(i)->GetSupportFiles(); 501 for (auto &f : support_files) { 502 files.AppendIfUnique(f->Materialize()); 503 } 504 } 505 return false; 506 }); 507 508 LLDB_LOG(log, "[C++ module config] Found {0} support files to analyze", 509 files.GetSize()); 510 if (log && log->GetVerbose()) { 511 for (auto &f : files) 512 LLDB_LOGV(log, "[C++ module config] Analyzing support file: {0}", 513 f.GetPath()); 514 } 515 516 // Try to create a configuration from the files. If there is no valid 517 // configuration possible with the files, this just returns an invalid 518 // configuration. 519 return CppModuleConfiguration(files, target->GetArchitecture().GetTriple()); 520} 521 522bool ClangUserExpression::PrepareForParsing( 523 DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, 524 bool for_completion) { 525 InstallContext(exe_ctx); 526 527 if (!SetupPersistentState(diagnostic_manager, exe_ctx)) 528 return false; 529 530 Status err; 531 ScanContext(exe_ctx, err); 532 533 if (!err.Success()) { 534 diagnostic_manager.PutString(eDiagnosticSeverityWarning, err.AsCString()); 535 } 536 537 //////////////////////////////////// 538 // Generate the expression 539 // 540 541 ApplyObjcCastHack(m_expr_text); 542 543 SetupDeclVendor(exe_ctx, m_target, diagnostic_manager); 544 545 m_filename = m_clang_state->GetNextExprFileName(); 546 547 if (m_target->GetImportStdModule() == eImportStdModuleTrue) 548 SetupCppModuleImports(exe_ctx); 549 550 CreateSourceCode(diagnostic_manager, exe_ctx, m_imported_cpp_modules, 551 for_completion); 552 return true; 553} 554 555bool ClangUserExpression::TryParse( 556 DiagnosticManager &diagnostic_manager, ExecutionContextScope *exe_scope, 557 ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy, 558 bool keep_result_in_memory, bool generate_debug_info) { 559 m_materializer_up = std::make_unique<Materializer>(); 560 561 ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory); 562 563 auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); }); 564 565 if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) { 566 diagnostic_manager.PutString( 567 eDiagnosticSeverityError, 568 "current process state is unsuitable for expression parsing"); 569 return false; 570 } 571 572 if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) { 573 DeclMap()->SetLookupsEnabled(true); 574 } 575 576 m_parser = std::make_unique<ClangExpressionParser>( 577 exe_scope, *this, generate_debug_info, m_include_directories, m_filename); 578 579 unsigned num_errors = m_parser->Parse(diagnostic_manager); 580 581 // Check here for FixItHints. If there are any try to apply the fixits and 582 // set the fixed text in m_fixed_text before returning an error. 583 if (num_errors) { 584 if (diagnostic_manager.HasFixIts()) { 585 if (m_parser->RewriteExpression(diagnostic_manager)) { 586 size_t fixed_start; 587 size_t fixed_end; 588 m_fixed_text = diagnostic_manager.GetFixedExpression(); 589 // Retrieve the original expression in case we don't have a top level 590 // expression (which has no surrounding source code). 591 if (m_source_code && m_source_code->GetOriginalBodyBounds( 592 m_fixed_text, fixed_start, fixed_end)) 593 m_fixed_text = 594 m_fixed_text.substr(fixed_start, fixed_end - fixed_start); 595 } 596 } 597 return false; 598 } 599 600 ////////////////////////////////////////////////////////////////////////////// 601 // Prepare the output of the parser for execution, evaluating it statically 602 // if possible 603 // 604 605 { 606 Status jit_error = m_parser->PrepareForExecution( 607 m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx, 608 m_can_interpret, execution_policy); 609 610 if (!jit_error.Success()) { 611 const char *error_cstr = jit_error.AsCString(); 612 if (error_cstr && error_cstr[0]) 613 diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr); 614 else 615 diagnostic_manager.PutString(eDiagnosticSeverityError, 616 "expression can't be interpreted or run"); 617 return false; 618 } 619 } 620 return true; 621} 622 623void ClangUserExpression::SetupCppModuleImports(ExecutionContext &exe_ctx) { 624 Log *log = GetLog(LLDBLog::Expressions); 625 626 CppModuleConfiguration module_config = GetModuleConfig(m_language, exe_ctx); 627 m_imported_cpp_modules = module_config.GetImportedModules(); 628 m_include_directories = module_config.GetIncludeDirs(); 629 630 LLDB_LOG(log, "List of imported modules in expression: {0}", 631 llvm::make_range(m_imported_cpp_modules.begin(), 632 m_imported_cpp_modules.end())); 633 LLDB_LOG(log, "List of include directories gathered for modules: {0}", 634 llvm::make_range(m_include_directories.begin(), 635 m_include_directories.end())); 636} 637 638static bool shouldRetryWithCppModule(Target &target, ExecutionPolicy exe_policy) { 639 // Top-level expression don't yet support importing C++ modules. 640 if (exe_policy == ExecutionPolicy::eExecutionPolicyTopLevel) 641 return false; 642 return target.GetImportStdModule() == eImportStdModuleFallback; 643} 644 645bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager, 646 ExecutionContext &exe_ctx, 647 lldb_private::ExecutionPolicy execution_policy, 648 bool keep_result_in_memory, 649 bool generate_debug_info) { 650 Log *log = GetLog(LLDBLog::Expressions); 651 652 if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ false)) 653 return false; 654 655 LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str()); 656 657 //////////////////////////////////// 658 // Set up the target and compiler 659 // 660 661 Target *target = exe_ctx.GetTargetPtr(); 662 663 if (!target) { 664 diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target"); 665 return false; 666 } 667 668 ////////////////////////// 669 // Parse the expression 670 // 671 672 Process *process = exe_ctx.GetProcessPtr(); 673 ExecutionContextScope *exe_scope = process; 674 675 if (!exe_scope) 676 exe_scope = exe_ctx.GetTargetPtr(); 677 678 bool parse_success = TryParse(diagnostic_manager, exe_scope, exe_ctx, 679 execution_policy, keep_result_in_memory, 680 generate_debug_info); 681 // If the expression failed to parse, check if retrying parsing with a loaded 682 // C++ module is possible. 683 if (!parse_success && shouldRetryWithCppModule(*target, execution_policy)) { 684 // Load the loaded C++ modules. 685 SetupCppModuleImports(exe_ctx); 686 // If we did load any modules, then retry parsing. 687 if (!m_imported_cpp_modules.empty()) { 688 // Create a dedicated diagnostic manager for the second parse attempt. 689 // These diagnostics are only returned to the caller if using the fallback 690 // actually succeeded in getting the expression to parse. This prevents 691 // that module-specific issues regress diagnostic quality with the 692 // fallback mode. 693 DiagnosticManager retry_manager; 694 // The module imports are injected into the source code wrapper, 695 // so recreate those. 696 CreateSourceCode(retry_manager, exe_ctx, m_imported_cpp_modules, 697 /*for_completion*/ false); 698 parse_success = TryParse(retry_manager, exe_scope, exe_ctx, 699 execution_policy, keep_result_in_memory, 700 generate_debug_info); 701 // Return the parse diagnostics if we were successful. 702 if (parse_success) 703 diagnostic_manager = std::move(retry_manager); 704 } 705 } 706 if (!parse_success) 707 return false; 708 709 if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) { 710 Status static_init_error = 711 m_parser->RunStaticInitializers(m_execution_unit_sp, exe_ctx); 712 713 if (!static_init_error.Success()) { 714 const char *error_cstr = static_init_error.AsCString(); 715 if (error_cstr && error_cstr[0]) 716 diagnostic_manager.Printf(eDiagnosticSeverityError, 717 "%s\n", 718 error_cstr); 719 else 720 diagnostic_manager.PutString(eDiagnosticSeverityError, 721 "couldn't run static initializers\n"); 722 return false; 723 } 724 } 725 726 if (m_execution_unit_sp) { 727 bool register_execution_unit = false; 728 729 if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) { 730 register_execution_unit = true; 731 } 732 733 // If there is more than one external function in the execution unit, it 734 // needs to keep living even if it's not top level, because the result 735 // could refer to that function. 736 737 if (m_execution_unit_sp->GetJittedFunctions().size() > 1) { 738 register_execution_unit = true; 739 } 740 741 if (register_execution_unit) { 742 if (auto *persistent_state = 743 exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage( 744 m_language)) 745 persistent_state->RegisterExecutionUnit(m_execution_unit_sp); 746 } 747 } 748 749 if (generate_debug_info) { 750 lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule()); 751 752 if (jit_module_sp) { 753 ConstString const_func_name(FunctionName()); 754 FileSpec jit_file; 755 jit_file.SetFilename(const_func_name); 756 jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString()); 757 m_jit_module_wp = jit_module_sp; 758 target->GetImages().Append(jit_module_sp); 759 } 760 } 761 762 if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS) 763 m_jit_process_wp = lldb::ProcessWP(process->shared_from_this()); 764 return true; 765} 766 767/// Converts an absolute position inside a given code string into 768/// a column/line pair. 769/// 770/// \param[in] abs_pos 771/// A absolute position in the code string that we want to convert 772/// to a column/line pair. 773/// 774/// \param[in] code 775/// A multi-line string usually representing source code. 776/// 777/// \param[out] line 778/// The line in the code that contains the given absolute position. 779/// The first line in the string is indexed as 1. 780/// 781/// \param[out] column 782/// The column in the line that contains the absolute position. 783/// The first character in a line is indexed as 0. 784static void AbsPosToLineColumnPos(size_t abs_pos, llvm::StringRef code, 785 unsigned &line, unsigned &column) { 786 // Reset to code position to beginning of the file. 787 line = 0; 788 column = 0; 789 790 assert(abs_pos <= code.size() && "Absolute position outside code string?"); 791 792 // We have to walk up to the position and count lines/columns. 793 for (std::size_t i = 0; i < abs_pos; ++i) { 794 // If we hit a line break, we go back to column 0 and enter a new line. 795 // We only handle \n because that's what we internally use to make new 796 // lines for our temporary code strings. 797 if (code[i] == '\n') { 798 ++line; 799 column = 0; 800 continue; 801 } 802 ++column; 803 } 804} 805 806bool ClangUserExpression::Complete(ExecutionContext &exe_ctx, 807 CompletionRequest &request, 808 unsigned complete_pos) { 809 Log *log = GetLog(LLDBLog::Expressions); 810 811 // We don't want any visible feedback when completing an expression. Mostly 812 // because the results we get from an incomplete invocation are probably not 813 // correct. 814 DiagnosticManager diagnostic_manager; 815 816 if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ true)) 817 return false; 818 819 LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str()); 820 821 ////////////////////////// 822 // Parse the expression 823 // 824 825 m_materializer_up = std::make_unique<Materializer>(); 826 827 ResetDeclMap(exe_ctx, m_result_delegate, /*keep result in memory*/ true); 828 829 auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); }); 830 831 if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) { 832 diagnostic_manager.PutString( 833 eDiagnosticSeverityError, 834 "current process state is unsuitable for expression parsing"); 835 836 return false; 837 } 838 839 if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) { 840 DeclMap()->SetLookupsEnabled(true); 841 } 842 843 Process *process = exe_ctx.GetProcessPtr(); 844 ExecutionContextScope *exe_scope = process; 845 846 if (!exe_scope) 847 exe_scope = exe_ctx.GetTargetPtr(); 848 849 ClangExpressionParser parser(exe_scope, *this, false); 850 851 // We have to find the source code location where the user text is inside 852 // the transformed expression code. When creating the transformed text, we 853 // already stored the absolute position in the m_transformed_text string. The 854 // only thing left to do is to transform it into the line:column format that 855 // Clang expects. 856 857 // The line and column of the user expression inside the transformed source 858 // code. 859 unsigned user_expr_line, user_expr_column; 860 if (m_user_expression_start_pos) 861 AbsPosToLineColumnPos(*m_user_expression_start_pos, m_transformed_text, 862 user_expr_line, user_expr_column); 863 else 864 return false; 865 866 // The actual column where we have to complete is the start column of the 867 // user expression + the offset inside the user code that we were given. 868 const unsigned completion_column = user_expr_column + complete_pos; 869 parser.Complete(request, user_expr_line, completion_column, complete_pos); 870 871 return true; 872} 873 874lldb::addr_t ClangUserExpression::GetCppObjectPointer( 875 lldb::StackFrameSP frame_sp, llvm::StringRef object_name, Status &err) { 876 auto valobj_sp = 877 GetObjectPointerValueObject(std::move(frame_sp), object_name, err); 878 879 // We're inside a C++ class method. This could potentially be an unnamed 880 // lambda structure. If the lambda captured a "this", that should be 881 // the object pointer. 882 if (auto thisChildSP = valobj_sp->GetChildMemberWithName("this")) { 883 valobj_sp = thisChildSP; 884 } 885 886 if (!err.Success() || !valobj_sp.get()) 887 return LLDB_INVALID_ADDRESS; 888 889 lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS); 890 891 if (ret == LLDB_INVALID_ADDRESS) { 892 err.SetErrorStringWithFormatv( 893 "Couldn't load '{0}' because its value couldn't be evaluated", 894 object_name); 895 return LLDB_INVALID_ADDRESS; 896 } 897 898 return ret; 899} 900 901bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx, 902 std::vector<lldb::addr_t> &args, 903 lldb::addr_t struct_address, 904 DiagnosticManager &diagnostic_manager) { 905 lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS; 906 lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS; 907 908 if (m_needs_object_ptr) { 909 lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP(); 910 if (!frame_sp) 911 return true; 912 913 if (!m_in_cplusplus_method && !m_in_objectivec_method) { 914 diagnostic_manager.PutString( 915 eDiagnosticSeverityError, 916 "need object pointer but don't know the language"); 917 return false; 918 } 919 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 = 923 m_in_cplusplus_method ? g_cplusplus_object_name : g_objc_object_name; 924 925 Status object_ptr_error; 926 927 if (m_ctx_obj) { 928 AddressType address_type; 929 object_ptr = m_ctx_obj->GetAddressOf(false, &address_type); 930 if (object_ptr == LLDB_INVALID_ADDRESS || 931 address_type != eAddressTypeLoad) 932 object_ptr_error.SetErrorString("Can't get context object's " 933 "debuggee address"); 934 } else { 935 if (m_in_cplusplus_method) { 936 object_ptr = 937 GetCppObjectPointer(frame_sp, object_name, object_ptr_error); 938 } else { 939 object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error); 940 } 941 } 942 943 if (!object_ptr_error.Success()) { 944 exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Format( 945 "warning: `{0}' is not accessible (substituting 0). {1}\n", 946 object_name, object_ptr_error.AsCString()); 947 object_ptr = 0; 948 } 949 950 if (m_in_objectivec_method) { 951 static constexpr llvm::StringLiteral cmd_name("_cmd"); 952 953 cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error); 954 955 if (!object_ptr_error.Success()) { 956 diagnostic_manager.Printf( 957 eDiagnosticSeverityWarning, 958 "couldn't get cmd pointer (substituting NULL): %s", 959 object_ptr_error.AsCString()); 960 cmd_ptr = 0; 961 } 962 } 963 964 args.push_back(object_ptr); 965 966 if (m_in_objectivec_method) 967 args.push_back(cmd_ptr); 968 969 args.push_back(struct_address); 970 } else { 971 args.push_back(struct_address); 972 } 973 return true; 974} 975 976lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization( 977 ExecutionContextScope *exe_scope) { 978 return m_result_delegate.GetVariable(); 979} 980 981char ClangUserExpression::ClangUserExpressionHelper::ID; 982 983void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap( 984 ExecutionContext &exe_ctx, 985 Materializer::PersistentVariableDelegate &delegate, 986 bool keep_result_in_memory, 987 ValueObject *ctx_obj) { 988 std::shared_ptr<ClangASTImporter> ast_importer; 989 auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage( 990 lldb::eLanguageTypeC); 991 if (state) { 992 auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state); 993 ast_importer = persistent_vars->GetClangASTImporter(); 994 } 995 m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>( 996 keep_result_in_memory, &delegate, exe_ctx.GetTargetSP(), ast_importer, 997 ctx_obj); 998} 999 1000clang::ASTConsumer * 1001ClangUserExpression::ClangUserExpressionHelper::ASTTransformer( 1002 clang::ASTConsumer *passthrough) { 1003 m_result_synthesizer_up = std::make_unique<ASTResultSynthesizer>( 1004 passthrough, m_top_level, m_target); 1005 1006 return m_result_synthesizer_up.get(); 1007} 1008 1009void ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls() { 1010 if (m_result_synthesizer_up) { 1011 m_result_synthesizer_up->CommitPersistentDecls(); 1012 } 1013} 1014 1015ConstString ClangUserExpression::ResultDelegate::GetName() { 1016 return m_persistent_state->GetNextPersistentVariableName(false); 1017} 1018 1019void ClangUserExpression::ResultDelegate::DidDematerialize( 1020 lldb::ExpressionVariableSP &variable) { 1021 m_variable = variable; 1022} 1023 1024void ClangUserExpression::ResultDelegate::RegisterPersistentState( 1025 PersistentExpressionState *persistent_state) { 1026 m_persistent_state = persistent_state; 1027} 1028 1029lldb::ExpressionVariableSP &ClangUserExpression::ResultDelegate::GetVariable() { 1030 return m_variable; 1031} 1032