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/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
  60 using namespace lldb_private;
  61
  62 char ClangUserExpression::ID;
  63
  64 ClangUserExpression::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
  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.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.
 314 static 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
 324 bool 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
 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(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
 397 ClangExpressionSourceCode::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
 413 void 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
 443 static 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.
 458 static 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
 464 CppModuleConfiguration 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 (const FileSpec &f : sc.comp_unit->GetSupportFiles())
 492     files.AppendIfUnique(f);
 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 FileSpecList &support_files =
 500               module.GetCompileUnitAtIndex(i)->GetSupportFiles();
 501           for (const FileSpec &f : support_files) {
 502             files.AppendIfUnique(f);
 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 (const FileSpec &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
 522 bool 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
 555 bool 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
 623 void 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
 638 static 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
 645 bool 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.
 784 static 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
 806 bool 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
 874 lldb::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
 901 bool 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
 976 lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
 977     ExecutionContextScope *exe_scope) {
 978   return m_result_delegate.GetVariable();
 979 }
 980
 981 char ClangUserExpression::ClangUserExpressionHelper::ID;
 982
 983 void 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
1000 clang::ASTConsumer *
1001 ClangUserExpression::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
1009 void ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls() {
1010   if (m_result_synthesizer_up) {
1011     m_result_synthesizer_up->CommitPersistentDecls();
1012   }
1013 }
1014
1015 ConstString ClangUserExpression::ResultDelegate::GetName() {
1016   return m_persistent_state->GetNextPersistentVariableName(false);
1017 }
1018
1019 void ClangUserExpression::ResultDelegate::DidDematerialize(
1020     lldb::ExpressionVariableSP &variable) {
1021   m_variable = variable;
1022 }
1023
1024 void ClangUserExpression::ResultDelegate::RegisterPersistentState(
1025     PersistentExpressionState *persistent_state) {
1026   m_persistent_state = persistent_state;
1027 }
1028
1029 lldb::ExpressionVariableSP &ClangUserExpression::ResultDelegate::GetVariable() {
1030   return m_variable;
1031 }