lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

   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/Expression/ExpressionSourceCode.h"
  31 #include "lldb/Expression/IRExecutionUnit.h"
  32 #include "lldb/Expression/IRInterpreter.h"
  33 #include "lldb/Expression/Materializer.h"
  34 #include "lldb/Host/HostInfo.h"
  35 #include "lldb/Symbol/Block.h"
  36 #include "lldb/Symbol/CompileUnit.h"
  37 #include "lldb/Symbol/Function.h"
  38 #include "lldb/Symbol/ObjectFile.h"
  39 #include "lldb/Symbol/SymbolFile.h"
  40 #include "lldb/Symbol/SymbolVendor.h"
  41 #include "lldb/Symbol/Type.h"
  42 #include "lldb/Symbol/VariableList.h"
  43 #include "lldb/Target/ExecutionContext.h"
  44 #include "lldb/Target/Process.h"
  45 #include "lldb/Target/StackFrame.h"
  46 #include "lldb/Target/Target.h"
  47 #include "lldb/Target/ThreadPlan.h"
  48 #include "lldb/Target/ThreadPlanCallUserExpression.h"
  49 #include "lldb/Utility/ConstString.h"
  50 #include "lldb/Utility/LLDBLog.h"
  51 #include "lldb/Utility/Log.h"
  52 #include "lldb/Utility/StreamString.h"
  53 #include "lldb/ValueObject/ValueObjectConstResult.h"
  54
  55 #include "clang/AST/DeclCXX.h"
  56 #include "clang/AST/DeclObjC.h"
  57
  58 #include "llvm/ADT/ScopeExit.h"
  59 #include "llvm/BinaryFormat/Dwarf.h"
  60
  61 using namespace lldb_private;
  62
  63 char ClangUserExpression::ID;
  64
  65 ClangUserExpression::ClangUserExpression(
  66     ExecutionContextScope &exe_scope, llvm::StringRef expr,
  67     llvm::StringRef prefix, SourceLanguage language, ResultType desired_type,
  68     const EvaluateExpressionOptions &options, 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.name) {
  75   case llvm::dwarf::DW_LNAME_C_plus_plus:
  76     m_allow_cxx = true;
  77     break;
  78   case llvm::dwarf::DW_LNAME_ObjC:
  79     m_allow_objc = true;
  80     break;
  81   case llvm::dwarf::DW_LNAME_ObjC_plus_plus:
  82   default:
  83     m_allow_cxx = true;
  84     m_allow_objc = true;
  85     break;
  86   }
  87 }
  88
  89 ClangUserExpression::~ClangUserExpression() = default;
  90
  91 void 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 = Status::FromErrorString(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 = Status::FromErrorString(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 = Status::FromErrorString(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 = Status::FromErrorString(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     if (std::optional<ClangASTMetadata> metadata =
 223             TypeSystemClang::DeclContextGetMetaData(decl_context,
 224                                                     function_decl);
 225         metadata && metadata->HasObjectPtr()) {
 226       lldb::LanguageType language = metadata->GetObjectPtrLanguage();
 227       if (language == lldb::eLanguageTypeC_plus_plus) {
 228         if (m_enforce_valid_object) {
 229           lldb::VariableListSP variable_list_sp(
 230               function_block->GetBlockVariableList(true));
 231
 232           const char *thisErrorString = "Stopped in a context claiming to "
 233                                         "capture a C++ object pointer, but "
 234                                         "'this' isn't available; pretending we "
 235                                         "are in a generic context";
 236
 237           if (!variable_list_sp) {
 238             err = Status::FromErrorString(thisErrorString);
 239             return;
 240           }
 241
 242           lldb::VariableSP this_var_sp(
 243               variable_list_sp->FindVariable(ConstString("this")));
 244
 245           if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
 246               !this_var_sp->LocationIsValidForFrame(frame)) {
 247             err = Status::FromErrorString(thisErrorString);
 248             return;
 249           }
 250         }
 251
 252         m_in_cplusplus_method = true;
 253         m_needs_object_ptr = true;
 254       } else if (language == lldb::eLanguageTypeObjC) {
 255         if (m_enforce_valid_object) {
 256           lldb::VariableListSP variable_list_sp(
 257               function_block->GetBlockVariableList(true));
 258
 259           const char *selfErrorString =
 260               "Stopped in a context claiming to capture an Objective-C object "
 261               "pointer, but 'self' isn't available; pretending we are in a "
 262               "generic context";
 263
 264           if (!variable_list_sp) {
 265             err = Status::FromErrorString(selfErrorString);
 266             return;
 267           }
 268
 269           lldb::VariableSP self_variable_sp =
 270               variable_list_sp->FindVariable(ConstString("self"));
 271
 272           if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
 273               !self_variable_sp->LocationIsValidForFrame(frame)) {
 274             err = Status::FromErrorString(selfErrorString);
 275             return;
 276           }
 277
 278           Type *self_type = self_variable_sp->GetType();
 279
 280           if (!self_type) {
 281             err = Status::FromErrorString(selfErrorString);
 282             return;
 283           }
 284
 285           CompilerType self_clang_type = self_type->GetForwardCompilerType();
 286
 287           if (!self_clang_type) {
 288             err = Status::FromErrorString(selfErrorString);
 289             return;
 290           }
 291
 292           if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
 293             return;
 294           } else if (TypeSystemClang::IsObjCObjectPointerType(
 295                          self_clang_type)) {
 296             m_in_objectivec_method = true;
 297             m_needs_object_ptr = true;
 298           } else {
 299             err = Status::FromErrorString(selfErrorString);
 300             return;
 301           }
 302         } else {
 303           m_in_objectivec_method = true;
 304           m_needs_object_ptr = true;
 305         }
 306       }
 307     }
 308   }
 309 }
 310
 311 // This is a really nasty hack, meant to fix Objective-C expressions of the
 312 // form (int)[myArray count].  Right now, because the type information for
 313 // count is not available, [myArray count] returns id, which can't be directly
 314 // cast to int without causing a clang error.
 315 static void ApplyObjcCastHack(std::string &expr) {
 316   const std::string from = "(int)[";
 317   const std::string to = "(int)(long long)[";
 318
 319   size_t offset;
 320
 321   while ((offset = expr.find(from)) != expr.npos)
 322     expr.replace(offset, from.size(), to);
 323 }
 324
 325 bool ClangUserExpression::SetupPersistentState(DiagnosticManager &diagnostic_manager,
 326                                  ExecutionContext &exe_ctx) {
 327   if (Target *target = exe_ctx.GetTargetPtr()) {
 328     if (PersistentExpressionState *persistent_state =
 329             target->GetPersistentExpressionStateForLanguage(
 330                 lldb::eLanguageTypeC)) {
 331       m_clang_state = llvm::cast<ClangPersistentVariables>(persistent_state);
 332       m_result_delegate.RegisterPersistentState(persistent_state);
 333     } else {
 334       diagnostic_manager.PutString(
 335           lldb::eSeverityError, "couldn't start parsing (no persistent data)");
 336       return false;
 337     }
 338   } else {
 339     diagnostic_manager.PutString(lldb::eSeverityError,
 340                                  "error: couldn't start parsing (no target)");
 341     return false;
 342   }
 343   return true;
 344 }
 345
 346 static 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(lldb::eSeverityInfo, error_stream.GetString());
 388     return;
 389   }
 390
 391   diagnostic_manager.PutString(lldb::eSeverityError,
 392                                "Unknown error while loading modules needed for "
 393                                "current compilation unit.");
 394 }
 395
 396 ClangExpressionSourceCode::WrapKind ClangUserExpression::GetWrapKind() const {
 397   assert(m_options.GetExecutionPolicy() != eExecutionPolicyTopLevel &&
 398          "Top level expressions aren't wrapped.");
 399   using Kind = ClangExpressionSourceCode::WrapKind;
 400   if (m_in_cplusplus_method)
 401     return Kind::CppMemberFunction;
 402   else if (m_in_objectivec_method) {
 403     if (m_in_static_method)
 404       return Kind::ObjCStaticMethod;
 405     return Kind::ObjCInstanceMethod;
 406   }
 407   // Not in any kind of 'special' function, so just wrap it in a normal C
 408   // function.
 409   return Kind::Function;
 410 }
 411
 412 void ClangUserExpression::CreateSourceCode(
 413     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
 414     std::vector<std::string> modules_to_import, bool for_completion) {
 415
 416   std::string prefix = m_expr_prefix;
 417
 418   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
 419     m_transformed_text = m_expr_text;
 420   } else {
 421     m_source_code.reset(ClangExpressionSourceCode::CreateWrapped(
 422         m_filename, prefix, m_expr_text, GetWrapKind()));
 423
 424     if (!m_source_code->GetText(m_transformed_text, exe_ctx, !m_ctx_obj,
 425                                 for_completion, modules_to_import)) {
 426       diagnostic_manager.PutString(lldb::eSeverityError,
 427                                    "couldn't construct expression body");
 428       return;
 429     }
 430
 431     // Find and store the start position of the original code inside the
 432     // transformed code. We need this later for the code completion.
 433     std::size_t original_start;
 434     std::size_t original_end;
 435     bool found_bounds = m_source_code->GetOriginalBodyBounds(
 436         m_transformed_text, original_start, original_end);
 437     if (found_bounds)
 438       m_user_expression_start_pos = original_start;
 439   }
 440 }
 441
 442 static bool SupportsCxxModuleImport(lldb::LanguageType language) {
 443   switch (language) {
 444   case lldb::eLanguageTypeC_plus_plus:
 445   case lldb::eLanguageTypeC_plus_plus_03:
 446   case lldb::eLanguageTypeC_plus_plus_11:
 447   case lldb::eLanguageTypeC_plus_plus_14:
 448   case lldb::eLanguageTypeObjC_plus_plus:
 449     return true;
 450   default:
 451     return false;
 452   }
 453 }
 454
 455 /// Utility method that puts a message into the expression log and
 456 /// returns an invalid module configuration.
 457 static CppModuleConfiguration LogConfigError(const std::string &msg) {
 458   Log *log = GetLog(LLDBLog::Expressions);
 459   LLDB_LOG(log, "[C++ module config] {0}", msg);
 460   return CppModuleConfiguration();
 461 }
 462
 463 CppModuleConfiguration GetModuleConfig(lldb::LanguageType language,
 464                                        ExecutionContext &exe_ctx) {
 465   Log *log = GetLog(LLDBLog::Expressions);
 466
 467   // Don't do anything if this is not a C++ module configuration.
 468   if (!SupportsCxxModuleImport(language))
 469     return LogConfigError("Language doesn't support C++ modules");
 470
 471   Target *target = exe_ctx.GetTargetPtr();
 472   if (!target)
 473     return LogConfigError("No target");
 474
 475   StackFrame *frame = exe_ctx.GetFramePtr();
 476   if (!frame)
 477     return LogConfigError("No frame");
 478
 479   Block *block = frame->GetFrameBlock();
 480   if (!block)
 481     return LogConfigError("No block");
 482
 483   SymbolContext sc;
 484   block->CalculateSymbolContext(&sc);
 485   if (!sc.comp_unit)
 486     return LogConfigError("Couldn't calculate symbol context");
 487
 488   // Build a list of files we need to analyze to build the configuration.
 489   FileSpecList files;
 490   for (auto &f : sc.comp_unit->GetSupportFiles())
 491     files.AppendIfUnique(f->Materialize());
 492   // We also need to look at external modules in the case of -gmodules as they
 493   // contain the support files for libc++ and the C library.
 494   llvm::DenseSet<SymbolFile *> visited_symbol_files;
 495   sc.comp_unit->ForEachExternalModule(
 496       visited_symbol_files, [&files](Module &module) {
 497         for (std::size_t i = 0; i < module.GetNumCompileUnits(); ++i) {
 498           const SupportFileList &support_files =
 499               module.GetCompileUnitAtIndex(i)->GetSupportFiles();
 500           for (auto &f : support_files) {
 501             files.AppendIfUnique(f->Materialize());
 502           }
 503         }
 504         return false;
 505       });
 506
 507   LLDB_LOG(log, "[C++ module config] Found {0} support files to analyze",
 508            files.GetSize());
 509   if (log && log->GetVerbose()) {
 510     for (auto &f : files)
 511       LLDB_LOGV(log, "[C++ module config] Analyzing support file: {0}",
 512                 f.GetPath());
 513   }
 514
 515   // Try to create a configuration from the files. If there is no valid
 516   // configuration possible with the files, this just returns an invalid
 517   // configuration.
 518   return CppModuleConfiguration(files, target->GetArchitecture().GetTriple());
 519 }
 520
 521 bool ClangUserExpression::PrepareForParsing(
 522     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
 523     bool for_completion) {
 524   InstallContext(exe_ctx);
 525
 526   if (!SetupPersistentState(diagnostic_manager, exe_ctx))
 527     return false;
 528
 529   Status err;
 530   ScanContext(exe_ctx, err);
 531
 532   if (!err.Success()) {
 533     diagnostic_manager.PutString(lldb::eSeverityWarning, err.AsCString());
 534   }
 535
 536   ////////////////////////////////////
 537   // Generate the expression
 538   //
 539
 540   ApplyObjcCastHack(m_expr_text);
 541
 542   SetupDeclVendor(exe_ctx, m_target, diagnostic_manager);
 543
 544   m_filename = m_clang_state->GetNextExprFileName();
 545
 546   if (m_target->GetImportStdModule() == eImportStdModuleTrue)
 547     SetupCppModuleImports(exe_ctx);
 548
 549   CreateSourceCode(diagnostic_manager, exe_ctx, m_imported_cpp_modules,
 550                    for_completion);
 551   return true;
 552 }
 553
 554 bool ClangUserExpression::TryParse(
 555     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
 556     lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory,
 557     bool generate_debug_info) {
 558   m_materializer_up = std::make_unique<Materializer>();
 559
 560   ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
 561
 562   auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); });
 563
 564   if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) {
 565     diagnostic_manager.PutString(
 566         lldb::eSeverityError,
 567         "current process state is unsuitable for expression parsing");
 568     return false;
 569   }
 570
 571   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
 572     DeclMap()->SetLookupsEnabled(true);
 573   }
 574
 575   m_parser = std::make_unique<ClangExpressionParser>(
 576       exe_ctx.GetBestExecutionContextScope(), *this, generate_debug_info,
 577       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(lldb::eSeverityError, error_cstr);
 614       else
 615         diagnostic_manager.PutString(lldb::eSeverityError,
 616                                      "expression can't be interpreted or run");
 617       return false;
 618     }
 619   }
 620   return true;
 621 }
 622
 623 void ClangUserExpression::SetupCppModuleImports(ExecutionContext &exe_ctx) {
 624   Log *log = GetLog(LLDBLog::Expressions);
 625
 626   CppModuleConfiguration module_config =
 627       GetModuleConfig(m_language.AsLanguageType(), exe_ctx);
 628   m_imported_cpp_modules = module_config.GetImportedModules();
 629   m_include_directories = module_config.GetIncludeDirs();
 630
 631   LLDB_LOG(log, "List of imported modules in expression: {0}",
 632            llvm::make_range(m_imported_cpp_modules.begin(),
 633                             m_imported_cpp_modules.end()));
 634   LLDB_LOG(log, "List of include directories gathered for modules: {0}",
 635            llvm::make_range(m_include_directories.begin(),
 636                             m_include_directories.end()));
 637 }
 638
 639 static bool shouldRetryWithCppModule(Target &target, ExecutionPolicy exe_policy) {
 640   // Top-level expression don't yet support importing C++ modules.
 641   if (exe_policy == ExecutionPolicy::eExecutionPolicyTopLevel)
 642     return false;
 643   return target.GetImportStdModule() == eImportStdModuleFallback;
 644 }
 645
 646 bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
 647                                 ExecutionContext &exe_ctx,
 648                                 lldb_private::ExecutionPolicy execution_policy,
 649                                 bool keep_result_in_memory,
 650                                 bool generate_debug_info) {
 651   Log *log = GetLog(LLDBLog::Expressions);
 652
 653   if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ false))
 654     return false;
 655
 656   LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
 657
 658   ////////////////////////////////////
 659   // Set up the target and compiler
 660   //
 661
 662   Target *target = exe_ctx.GetTargetPtr();
 663
 664   if (!target) {
 665     diagnostic_manager.PutString(lldb::eSeverityError, "invalid target");
 666     return false;
 667   }
 668
 669   //////////////////////////
 670   // Parse the expression
 671   //
 672
 673   bool parse_success = TryParse(diagnostic_manager, exe_ctx, execution_policy,
 674                                 keep_result_in_memory, generate_debug_info);
 675   // If the expression failed to parse, check if retrying parsing with a loaded
 676   // C++ module is possible.
 677   if (!parse_success && shouldRetryWithCppModule(*target, execution_policy)) {
 678     // Load the loaded C++ modules.
 679     SetupCppModuleImports(exe_ctx);
 680     // If we did load any modules, then retry parsing.
 681     if (!m_imported_cpp_modules.empty()) {
 682       // Create a dedicated diagnostic manager for the second parse attempt.
 683       // These diagnostics are only returned to the caller if using the fallback
 684       // actually succeeded in getting the expression to parse. This prevents
 685       // that module-specific issues regress diagnostic quality with the
 686       // fallback mode.
 687       DiagnosticManager retry_manager;
 688       // The module imports are injected into the source code wrapper,
 689       // so recreate those.
 690       CreateSourceCode(retry_manager, exe_ctx, m_imported_cpp_modules,
 691                        /*for_completion*/ false);
 692       parse_success = TryParse(retry_manager, exe_ctx, execution_policy,
 693                                keep_result_in_memory, generate_debug_info);
 694       // Return the parse diagnostics if we were successful.
 695       if (parse_success)
 696         diagnostic_manager = std::move(retry_manager);
 697     }
 698   }
 699   if (!parse_success)
 700     return false;
 701
 702   if (m_execution_unit_sp) {
 703     bool register_execution_unit = false;
 704
 705     if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
 706       register_execution_unit = true;
 707     }
 708
 709     // If there is more than one external function in the execution unit, it
 710     // needs to keep living even if it's not top level, because the result
 711     // could refer to that function.
 712
 713     if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
 714       register_execution_unit = true;
 715     }
 716
 717     if (register_execution_unit) {
 718       if (auto *persistent_state =
 719               exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(
 720                   m_language.AsLanguageType()))
 721         persistent_state->RegisterExecutionUnit(m_execution_unit_sp);
 722     }
 723   }
 724
 725   if (generate_debug_info) {
 726     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
 727
 728     if (jit_module_sp) {
 729       ConstString const_func_name(FunctionName());
 730       FileSpec jit_file;
 731       jit_file.SetFilename(const_func_name);
 732       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
 733       m_jit_module_wp = jit_module_sp;
 734       target->GetImages().Append(jit_module_sp);
 735     }
 736   }
 737
 738   Process *process = exe_ctx.GetProcessPtr();
 739   if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
 740     m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
 741   return true;
 742 }
 743
 744 /// Converts an absolute position inside a given code string into
 745 /// a column/line pair.
 746 ///
 747 /// \param[in] abs_pos
 748 ///     A absolute position in the code string that we want to convert
 749 ///     to a column/line pair.
 750 ///
 751 /// \param[in] code
 752 ///     A multi-line string usually representing source code.
 753 ///
 754 /// \param[out] line
 755 ///     The line in the code that contains the given absolute position.
 756 ///     The first line in the string is indexed as 1.
 757 ///
 758 /// \param[out] column
 759 ///     The column in the line that contains the absolute position.
 760 ///     The first character in a line is indexed as 0.
 761 static void AbsPosToLineColumnPos(size_t abs_pos, llvm::StringRef code,
 762                                   unsigned &line, unsigned &column) {
 763   // Reset to code position to beginning of the file.
 764   line = 0;
 765   column = 0;
 766
 767   assert(abs_pos <= code.size() && "Absolute position outside code string?");
 768
 769   // We have to walk up to the position and count lines/columns.
 770   for (std::size_t i = 0; i < abs_pos; ++i) {
 771     // If we hit a line break, we go back to column 0 and enter a new line.
 772     // We only handle \n because that's what we internally use to make new
 773     // lines for our temporary code strings.
 774     if (code[i] == '\n') {
 775       ++line;
 776       column = 0;
 777       continue;
 778     }
 779     ++column;
 780   }
 781 }
 782
 783 bool ClangUserExpression::Complete(ExecutionContext &exe_ctx,
 784                                    CompletionRequest &request,
 785                                    unsigned complete_pos) {
 786   Log *log = GetLog(LLDBLog::Expressions);
 787
 788   // We don't want any visible feedback when completing an expression. Mostly
 789   // because the results we get from an incomplete invocation are probably not
 790   // correct.
 791   DiagnosticManager diagnostic_manager;
 792
 793   if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ true))
 794     return false;
 795
 796   LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
 797
 798   //////////////////////////
 799   // Parse the expression
 800   //
 801
 802   m_materializer_up = std::make_unique<Materializer>();
 803
 804   ResetDeclMap(exe_ctx, m_result_delegate, /*keep result in memory*/ true);
 805
 806   auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); });
 807
 808   if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) {
 809     diagnostic_manager.PutString(
 810         lldb::eSeverityError,
 811         "current process state is unsuitable for expression parsing");
 812
 813     return false;
 814   }
 815
 816   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
 817     DeclMap()->SetLookupsEnabled(true);
 818   }
 819
 820   ClangExpressionParser parser(exe_ctx.GetBestExecutionContextScope(), *this,
 821                                false);
 822
 823   // We have to find the source code location where the user text is inside
 824   // the transformed expression code. When creating the transformed text, we
 825   // already stored the absolute position in the m_transformed_text string. The
 826   // only thing left to do is to transform it into the line:column format that
 827   // Clang expects.
 828
 829   // The line and column of the user expression inside the transformed source
 830   // code.
 831   unsigned user_expr_line, user_expr_column;
 832   if (m_user_expression_start_pos)
 833     AbsPosToLineColumnPos(*m_user_expression_start_pos, m_transformed_text,
 834                           user_expr_line, user_expr_column);
 835   else
 836     return false;
 837
 838   // The actual column where we have to complete is the start column of the
 839   // user expression + the offset inside the user code that we were given.
 840   const unsigned completion_column = user_expr_column + complete_pos;
 841   parser.Complete(request, user_expr_line, completion_column, complete_pos);
 842
 843   return true;
 844 }
 845
 846 lldb::addr_t ClangUserExpression::GetCppObjectPointer(
 847     lldb::StackFrameSP frame_sp, llvm::StringRef object_name, Status &err) {
 848   auto valobj_sp =
 849       GetObjectPointerValueObject(std::move(frame_sp), object_name, err);
 850
 851   // We're inside a C++ class method. This could potentially be an unnamed
 852   // lambda structure. If the lambda captured a "this", that should be
 853   // the object pointer.
 854   if (auto thisChildSP = valobj_sp->GetChildMemberWithName("this")) {
 855     valobj_sp = thisChildSP;
 856   }
 857
 858   if (!err.Success() || !valobj_sp.get())
 859     return LLDB_INVALID_ADDRESS;
 860
 861   lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 862
 863   if (ret == LLDB_INVALID_ADDRESS) {
 864     err = Status::FromErrorStringWithFormatv(
 865         "Couldn't load '{0}' because its value couldn't be evaluated",
 866         object_name);
 867     return LLDB_INVALID_ADDRESS;
 868   }
 869
 870   return ret;
 871 }
 872
 873 bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
 874                                        std::vector<lldb::addr_t> &args,
 875                                        lldb::addr_t struct_address,
 876                                        DiagnosticManager &diagnostic_manager) {
 877   lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
 878   lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
 879
 880   if (m_needs_object_ptr) {
 881     lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
 882     if (!frame_sp)
 883       return true;
 884
 885     if (!m_in_cplusplus_method && !m_in_objectivec_method) {
 886       diagnostic_manager.PutString(
 887           lldb::eSeverityError,
 888           "need object pointer but don't know the language");
 889       return false;
 890     }
 891
 892     static constexpr llvm::StringLiteral g_cplusplus_object_name("this");
 893     static constexpr llvm::StringLiteral g_objc_object_name("self");
 894     llvm::StringRef object_name =
 895         m_in_cplusplus_method ? g_cplusplus_object_name : g_objc_object_name;
 896
 897     Status object_ptr_error;
 898
 899     if (m_ctx_obj) {
 900       AddressType address_type;
 901       object_ptr = m_ctx_obj->GetAddressOf(false, &address_type);
 902       if (object_ptr == LLDB_INVALID_ADDRESS ||
 903           address_type != eAddressTypeLoad)
 904         object_ptr_error = Status::FromErrorString("Can't get context object's "
 905                                                    "debuggee address");
 906     } else {
 907       if (m_in_cplusplus_method) {
 908         object_ptr =
 909             GetCppObjectPointer(frame_sp, object_name, object_ptr_error);
 910       } else {
 911         object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
 912       }
 913     }
 914
 915     if (!object_ptr_error.Success()) {
 916       exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Format(
 917           "warning: `{0}' is not accessible (substituting 0). {1}\n",
 918           object_name, object_ptr_error.AsCString());
 919       object_ptr = 0;
 920     }
 921
 922     if (m_in_objectivec_method) {
 923       static constexpr llvm::StringLiteral cmd_name("_cmd");
 924
 925       cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error);
 926
 927       if (!object_ptr_error.Success()) {
 928         diagnostic_manager.Printf(
 929             lldb::eSeverityWarning,
 930             "couldn't get cmd pointer (substituting NULL): %s",
 931             object_ptr_error.AsCString());
 932         cmd_ptr = 0;
 933       }
 934     }
 935
 936     args.push_back(object_ptr);
 937
 938     if (m_in_objectivec_method)
 939       args.push_back(cmd_ptr);
 940
 941     args.push_back(struct_address);
 942   } else {
 943     args.push_back(struct_address);
 944   }
 945   return true;
 946 }
 947
 948 lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
 949     ExecutionContextScope *exe_scope) {
 950   return m_result_delegate.GetVariable();
 951 }
 952
 953 char ClangUserExpression::ClangUserExpressionHelper::ID;
 954
 955 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
 956     ExecutionContext &exe_ctx,
 957     Materializer::PersistentVariableDelegate &delegate,
 958     bool keep_result_in_memory,
 959     ValueObject *ctx_obj) {
 960   std::shared_ptr<ClangASTImporter> ast_importer;
 961   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
 962       lldb::eLanguageTypeC);
 963   if (state) {
 964     auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
 965     ast_importer = persistent_vars->GetClangASTImporter();
 966   }
 967   m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
 968       keep_result_in_memory, &delegate, exe_ctx.GetTargetSP(), ast_importer,
 969       ctx_obj);
 970 }
 971
 972 clang::ASTConsumer *
 973 ClangUserExpression::ClangUserExpressionHelper::ASTTransformer(
 974     clang::ASTConsumer *passthrough) {
 975   m_result_synthesizer_up = std::make_unique<ASTResultSynthesizer>(
 976       passthrough, m_top_level, m_target);
 977
 978   return m_result_synthesizer_up.get();
 979 }
 980
 981 void ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls() {
 982   if (m_result_synthesizer_up) {
 983     m_result_synthesizer_up->CommitPersistentDecls();
 984   }
 985 }
 986
 987 ConstString ClangUserExpression::ResultDelegate::GetName() {
 988   return m_persistent_state->GetNextPersistentVariableName(false);
 989 }
 990
 991 void ClangUserExpression::ResultDelegate::DidDematerialize(
 992     lldb::ExpressionVariableSP &variable) {
 993   m_variable = variable;
 994 }
 995
 996 void ClangUserExpression::ResultDelegate::RegisterPersistentState(
 997     PersistentExpressionState *persistent_state) {
 998   m_persistent_state = persistent_state;
 999 }
1000
1001 lldb::ExpressionVariableSP &ClangUserExpression::ResultDelegate::GetVariable() {
1002   return m_variable;
1003 }