1//===-- ClangExpressionParser.cpp -------------------------------*- C++ -*-===// 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 "clang/AST/ASTContext.h" 10#include "clang/AST/ASTDiagnostic.h" 11#include "clang/AST/ExternalASTSource.h" 12#include "clang/AST/PrettyPrinter.h" 13#include "clang/Basic/Builtins.h" 14#include "clang/Basic/DiagnosticIDs.h" 15#include "clang/Basic/SourceLocation.h" 16#include "clang/Basic/TargetInfo.h" 17#include "clang/Basic/Version.h" 18#include "clang/CodeGen/CodeGenAction.h" 19#include "clang/CodeGen/ModuleBuilder.h" 20#include "clang/Edit/Commit.h" 21#include "clang/Edit/EditedSource.h" 22#include "clang/Edit/EditsReceiver.h" 23#include "clang/Frontend/CompilerInstance.h" 24#include "clang/Frontend/CompilerInvocation.h" 25#include "clang/Frontend/FrontendActions.h" 26#include "clang/Frontend/FrontendDiagnostic.h" 27#include "clang/Frontend/FrontendPluginRegistry.h" 28#include "clang/Frontend/TextDiagnosticBuffer.h" 29#include "clang/Frontend/TextDiagnosticPrinter.h" 30#include "clang/Lex/Preprocessor.h" 31#include "clang/Parse/ParseAST.h" 32#include "clang/Rewrite/Core/Rewriter.h" 33#include "clang/Rewrite/Frontend/FrontendActions.h" 34#include "clang/Sema/CodeCompleteConsumer.h" 35#include "clang/Sema/Sema.h" 36#include "clang/Sema/SemaConsumer.h" 37 38#include "llvm/ADT/StringRef.h" 39#include "llvm/ExecutionEngine/ExecutionEngine.h" 40#include "llvm/Support/CrashRecoveryContext.h" 41#include "llvm/Support/Debug.h" 42#include "llvm/Support/FileSystem.h" 43#include "llvm/Support/TargetSelect.h" 44 45#include "llvm/IR/LLVMContext.h" 46#include "llvm/IR/Module.h" 47#include "llvm/Support/DynamicLibrary.h" 48#include "llvm/Support/ErrorHandling.h" 49#include "llvm/Support/Host.h" 50#include "llvm/Support/MemoryBuffer.h" 51#include "llvm/Support/Signals.h" 52 53#include "ClangDiagnostic.h" 54#include "ClangExpressionParser.h" 55#include "ClangUserExpression.h" 56 57#include "ASTUtils.h" 58#include "ClangASTSource.h" 59#include "ClangDiagnostic.h" 60#include "ClangExpressionDeclMap.h" 61#include "ClangExpressionHelper.h" 62#include "ClangExpressionParser.h" 63#include "ClangHost.h" 64#include "ClangModulesDeclVendor.h" 65#include "ClangPersistentVariables.h" 66#include "IRDynamicChecks.h" 67#include "IRForTarget.h" 68#include "ModuleDependencyCollector.h" 69 70#include "lldb/Core/Debugger.h" 71#include "lldb/Core/Disassembler.h" 72#include "lldb/Core/Module.h" 73#include "lldb/Core/StreamFile.h" 74#include "lldb/Expression/IRExecutionUnit.h" 75#include "lldb/Expression/IRInterpreter.h" 76#include "lldb/Host/File.h" 77#include "lldb/Host/HostInfo.h" 78#include "lldb/Symbol/ClangASTContext.h" 79#include "lldb/Symbol/SymbolVendor.h" 80#include "lldb/Target/ExecutionContext.h" 81#include "lldb/Target/Language.h" 82#include "lldb/Target/Process.h" 83#include "lldb/Target/Target.h" 84#include "lldb/Target/ThreadPlanCallFunction.h" 85#include "lldb/Utility/DataBufferHeap.h" 86#include "lldb/Utility/LLDBAssert.h" 87#include "lldb/Utility/Log.h" 88#include "lldb/Utility/Reproducer.h" 89#include "lldb/Utility/Stream.h" 90#include "lldb/Utility/StreamString.h" 91#include "lldb/Utility/StringList.h" 92 93#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" 94 95#include <cctype> 96#include <memory> 97 98using namespace clang; 99using namespace llvm; 100using namespace lldb_private; 101 102//===----------------------------------------------------------------------===// 103// Utility Methods for Clang 104//===----------------------------------------------------------------------===// 105 106class ClangExpressionParser::LLDBPreprocessorCallbacks : public PPCallbacks { 107 ClangModulesDeclVendor &m_decl_vendor; 108 ClangPersistentVariables &m_persistent_vars; 109 clang::SourceManager &m_source_mgr; 110 StreamString m_error_stream; 111 bool m_has_errors = false; 112 113public: 114 LLDBPreprocessorCallbacks(ClangModulesDeclVendor &decl_vendor, 115 ClangPersistentVariables &persistent_vars, 116 clang::SourceManager &source_mgr) 117 : m_decl_vendor(decl_vendor), m_persistent_vars(persistent_vars), 118 m_source_mgr(source_mgr) {} 119 120 void moduleImport(SourceLocation import_location, clang::ModuleIdPath path, 121 const clang::Module * /*null*/) override { 122 // Ignore modules that are imported in the wrapper code as these are not 123 // loaded by the user. 124 llvm::StringRef filename = 125 m_source_mgr.getPresumedLoc(import_location).getFilename(); 126 if (filename == ClangExpressionSourceCode::g_prefix_file_name) 127 return; 128 129 SourceModule module; 130 131 for (const std::pair<IdentifierInfo *, SourceLocation> &component : path) 132 module.path.push_back(ConstString(component.first->getName())); 133 134 StreamString error_stream; 135 136 ClangModulesDeclVendor::ModuleVector exported_modules; 137 if (!m_decl_vendor.AddModule(module, &exported_modules, m_error_stream)) 138 m_has_errors = true; 139 140 for (ClangModulesDeclVendor::ModuleID module : exported_modules) 141 m_persistent_vars.AddHandLoadedClangModule(module); 142 } 143 144 bool hasErrors() { return m_has_errors; } 145 146 llvm::StringRef getErrorString() { return m_error_stream.GetString(); } 147}; 148 149class ClangDiagnosticManagerAdapter : public clang::DiagnosticConsumer { 150public: 151 ClangDiagnosticManagerAdapter(DiagnosticOptions &opts) { 152 DiagnosticOptions *m_options = new DiagnosticOptions(opts); 153 m_options->ShowPresumedLoc = true; 154 m_options->ShowLevel = false; 155 m_os.reset(new llvm::raw_string_ostream(m_output)); 156 m_passthrough.reset( 157 new clang::TextDiagnosticPrinter(*m_os, m_options, false)); 158 } 159 160 void ResetManager(DiagnosticManager *manager = nullptr) { 161 m_manager = manager; 162 } 163 164 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, 165 const clang::Diagnostic &Info) override { 166 if (!m_manager) { 167 // We have no DiagnosticManager before/after parsing but we still could 168 // receive diagnostics (e.g., by the ASTImporter failing to copy decls 169 // when we move the expression result ot the ScratchASTContext). Let's at 170 // least log these diagnostics until we find a way to properly render 171 // them and display them to the user. 172 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 173 if (log) { 174 llvm::SmallVector<char, 32> diag_str; 175 Info.FormatDiagnostic(diag_str); 176 diag_str.push_back('\0'); 177 const char *plain_diag = diag_str.data(); 178 LLDB_LOG(log, "Received diagnostic outside parsing: {0}", plain_diag); 179 } 180 return; 181 } 182 183 // Render diagnostic message to m_output. 184 m_output.clear(); 185 m_passthrough->HandleDiagnostic(DiagLevel, Info); 186 m_os->flush(); 187 188 lldb_private::DiagnosticSeverity severity; 189 bool make_new_diagnostic = true; 190 191 switch (DiagLevel) { 192 case DiagnosticsEngine::Level::Fatal: 193 case DiagnosticsEngine::Level::Error: 194 severity = eDiagnosticSeverityError; 195 break; 196 case DiagnosticsEngine::Level::Warning: 197 severity = eDiagnosticSeverityWarning; 198 break; 199 case DiagnosticsEngine::Level::Remark: 200 case DiagnosticsEngine::Level::Ignored: 201 severity = eDiagnosticSeverityRemark; 202 break; 203 case DiagnosticsEngine::Level::Note: 204 m_manager->AppendMessageToDiagnostic(m_output); 205 make_new_diagnostic = false; 206 } 207 if (make_new_diagnostic) { 208 // ClangDiagnostic messages are expected to have no whitespace/newlines 209 // around them. 210 std::string stripped_output = llvm::StringRef(m_output).trim(); 211 212 auto new_diagnostic = std::make_unique<ClangDiagnostic>( 213 stripped_output, severity, Info.getID()); 214 215 // Don't store away warning fixits, since the compiler doesn't have 216 // enough context in an expression for the warning to be useful. 217 // FIXME: Should we try to filter out FixIts that apply to our generated 218 // code, and not the user's expression? 219 if (severity == eDiagnosticSeverityError) { 220 size_t num_fixit_hints = Info.getNumFixItHints(); 221 for (size_t i = 0; i < num_fixit_hints; i++) { 222 const clang::FixItHint &fixit = Info.getFixItHint(i); 223 if (!fixit.isNull()) 224 new_diagnostic->AddFixitHint(fixit); 225 } 226 } 227 228 m_manager->AddDiagnostic(std::move(new_diagnostic)); 229 } 230 } 231 232 clang::TextDiagnosticPrinter *GetPassthrough() { return m_passthrough.get(); } 233 234private: 235 DiagnosticManager *m_manager = nullptr; 236 std::shared_ptr<clang::TextDiagnosticPrinter> m_passthrough; 237 /// Output stream of m_passthrough. 238 std::shared_ptr<llvm::raw_string_ostream> m_os; 239 /// Output string filled by m_os. 240 std::string m_output; 241}; 242 243static void SetupModuleHeaderPaths(CompilerInstance *compiler, 244 std::vector<std::string> include_directories, 245 lldb::TargetSP target_sp) { 246 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 247 248 HeaderSearchOptions &search_opts = compiler->getHeaderSearchOpts(); 249 250 for (const std::string &dir : include_directories) { 251 search_opts.AddPath(dir, frontend::System, false, true); 252 LLDB_LOG(log, "Added user include dir: {0}", dir); 253 } 254 255 llvm::SmallString<128> module_cache; 256 auto props = ModuleList::GetGlobalModuleListProperties(); 257 props.GetClangModulesCachePath().GetPath(module_cache); 258 search_opts.ModuleCachePath = module_cache.str(); 259 LLDB_LOG(log, "Using module cache path: {0}", module_cache.c_str()); 260 261 search_opts.ResourceDir = GetClangResourceDir().GetPath(); 262 263 search_opts.ImplicitModuleMaps = true; 264} 265 266//===----------------------------------------------------------------------===// 267// Implementation of ClangExpressionParser 268//===----------------------------------------------------------------------===// 269 270ClangExpressionParser::ClangExpressionParser( 271 ExecutionContextScope *exe_scope, Expression &expr, 272 bool generate_debug_info, std::vector<std::string> include_directories, 273 std::string filename) 274 : ExpressionParser(exe_scope, expr, generate_debug_info), m_compiler(), 275 m_pp_callbacks(nullptr), 276 m_include_directories(std::move(include_directories)), 277 m_filename(std::move(filename)) { 278 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 279 280 // We can't compile expressions without a target. So if the exe_scope is 281 // null or doesn't have a target, then we just need to get out of here. I'll 282 // lldb_assert and not make any of the compiler objects since 283 // I can't return errors directly from the constructor. Further calls will 284 // check if the compiler was made and 285 // bag out if it wasn't. 286 287 if (!exe_scope) { 288 lldb_assert(exe_scope, "Can't make an expression parser with a null scope.", 289 __FUNCTION__, __FILE__, __LINE__); 290 return; 291 } 292 293 lldb::TargetSP target_sp; 294 target_sp = exe_scope->CalculateTarget(); 295 if (!target_sp) { 296 lldb_assert(target_sp.get(), 297 "Can't make an expression parser with a null target.", 298 __FUNCTION__, __FILE__, __LINE__); 299 return; 300 } 301 302 // 1. Create a new compiler instance. 303 m_compiler.reset(new CompilerInstance()); 304 305 // When capturing a reproducer, hook up the file collector with clang to 306 // collector modules and headers. 307 if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) { 308 repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>(); 309 m_compiler->setModuleDepCollector( 310 std::make_shared<ModuleDependencyCollectorAdaptor>( 311 fp.GetFileCollector())); 312 DependencyOutputOptions &opts = m_compiler->getDependencyOutputOpts(); 313 opts.IncludeSystemHeaders = true; 314 opts.IncludeModuleFiles = true; 315 } 316 317 // Make sure clang uses the same VFS as LLDB. 318 m_compiler->createFileManager(FileSystem::Instance().GetVirtualFileSystem()); 319 320 lldb::LanguageType frame_lang = 321 expr.Language(); // defaults to lldb::eLanguageTypeUnknown 322 bool overridden_target_opts = false; 323 lldb_private::LanguageRuntime *lang_rt = nullptr; 324 325 std::string abi; 326 ArchSpec target_arch; 327 target_arch = target_sp->GetArchitecture(); 328 329 const auto target_machine = target_arch.GetMachine(); 330 331 // If the expression is being evaluated in the context of an existing stack 332 // frame, we introspect to see if the language runtime is available. 333 334 lldb::StackFrameSP frame_sp = exe_scope->CalculateStackFrame(); 335 lldb::ProcessSP process_sp = exe_scope->CalculateProcess(); 336 337 // Make sure the user hasn't provided a preferred execution language with 338 // `expression --language X -- ...` 339 if (frame_sp && frame_lang == lldb::eLanguageTypeUnknown) 340 frame_lang = frame_sp->GetLanguage(); 341 342 if (process_sp && frame_lang != lldb::eLanguageTypeUnknown) { 343 lang_rt = process_sp->GetLanguageRuntime(frame_lang); 344 LLDB_LOGF(log, "Frame has language of type %s", 345 Language::GetNameForLanguageType(frame_lang)); 346 } 347 348 // 2. Configure the compiler with a set of default options that are 349 // appropriate for most situations. 350 if (target_arch.IsValid()) { 351 std::string triple = target_arch.GetTriple().str(); 352 m_compiler->getTargetOpts().Triple = triple; 353 LLDB_LOGF(log, "Using %s as the target triple", 354 m_compiler->getTargetOpts().Triple.c_str()); 355 } else { 356 // If we get here we don't have a valid target and just have to guess. 357 // Sometimes this will be ok to just use the host target triple (when we 358 // evaluate say "2+3", but other expressions like breakpoint conditions and 359 // other things that _are_ target specific really shouldn't just be using 360 // the host triple. In such a case the language runtime should expose an 361 // overridden options set (3), below. 362 m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple(); 363 LLDB_LOGF(log, "Using default target triple of %s", 364 m_compiler->getTargetOpts().Triple.c_str()); 365 } 366 // Now add some special fixes for known architectures: Any arm32 iOS 367 // environment, but not on arm64 368 if (m_compiler->getTargetOpts().Triple.find("arm64") == std::string::npos && 369 m_compiler->getTargetOpts().Triple.find("arm") != std::string::npos && 370 m_compiler->getTargetOpts().Triple.find("ios") != std::string::npos) { 371 m_compiler->getTargetOpts().ABI = "apcs-gnu"; 372 } 373 // Supported subsets of x86 374 if (target_machine == llvm::Triple::x86 || 375 target_machine == llvm::Triple::x86_64) { 376 m_compiler->getTargetOpts().Features.push_back("+sse"); 377 m_compiler->getTargetOpts().Features.push_back("+sse2"); 378 } 379 380 // Set the target CPU to generate code for. This will be empty for any CPU 381 // that doesn't really need to make a special 382 // CPU string. 383 m_compiler->getTargetOpts().CPU = target_arch.GetClangTargetCPU(); 384 385 // Set the target ABI 386 abi = GetClangTargetABI(target_arch); 387 if (!abi.empty()) 388 m_compiler->getTargetOpts().ABI = abi; 389 390 // 3. Now allow the runtime to provide custom configuration options for the 391 // target. In this case, a specialized language runtime is available and we 392 // can query it for extra options. For 99% of use cases, this will not be 393 // needed and should be provided when basic platform detection is not enough. 394 if (lang_rt) 395 overridden_target_opts = 396 lang_rt->GetOverrideExprOptions(m_compiler->getTargetOpts()); 397 398 if (overridden_target_opts) 399 if (log && log->GetVerbose()) { 400 LLDB_LOGV( 401 log, "Using overridden target options for the expression evaluation"); 402 403 auto opts = m_compiler->getTargetOpts(); 404 LLDB_LOGV(log, "Triple: '{0}'", opts.Triple); 405 LLDB_LOGV(log, "CPU: '{0}'", opts.CPU); 406 LLDB_LOGV(log, "FPMath: '{0}'", opts.FPMath); 407 LLDB_LOGV(log, "ABI: '{0}'", opts.ABI); 408 LLDB_LOGV(log, "LinkerVersion: '{0}'", opts.LinkerVersion); 409 StringList::LogDump(log, opts.FeaturesAsWritten, "FeaturesAsWritten"); 410 StringList::LogDump(log, opts.Features, "Features"); 411 } 412 413 // 4. Create and install the target on the compiler. 414 m_compiler->createDiagnostics(); 415 auto target_info = TargetInfo::CreateTargetInfo( 416 m_compiler->getDiagnostics(), m_compiler->getInvocation().TargetOpts); 417 if (log) { 418 LLDB_LOGF(log, "Using SIMD alignment: %d", 419 target_info->getSimdDefaultAlign()); 420 LLDB_LOGF(log, "Target datalayout string: '%s'", 421 target_info->getDataLayout().getStringRepresentation().c_str()); 422 LLDB_LOGF(log, "Target ABI: '%s'", target_info->getABI().str().c_str()); 423 LLDB_LOGF(log, "Target vector alignment: %d", 424 target_info->getMaxVectorAlign()); 425 } 426 m_compiler->setTarget(target_info); 427 428 assert(m_compiler->hasTarget()); 429 430 // 5. Set language options. 431 lldb::LanguageType language = expr.Language(); 432 LangOptions &lang_opts = m_compiler->getLangOpts(); 433 434 switch (language) { 435 case lldb::eLanguageTypeC: 436 case lldb::eLanguageTypeC89: 437 case lldb::eLanguageTypeC99: 438 case lldb::eLanguageTypeC11: 439 // FIXME: the following language option is a temporary workaround, 440 // to "ask for C, get C++." 441 // For now, the expression parser must use C++ anytime the language is a C 442 // family language, because the expression parser uses features of C++ to 443 // capture values. 444 lang_opts.CPlusPlus = true; 445 break; 446 case lldb::eLanguageTypeObjC: 447 lang_opts.ObjC = true; 448 // FIXME: the following language option is a temporary workaround, 449 // to "ask for ObjC, get ObjC++" (see comment above). 450 lang_opts.CPlusPlus = true; 451 452 // Clang now sets as default C++14 as the default standard (with 453 // GNU extensions), so we do the same here to avoid mismatches that 454 // cause compiler error when evaluating expressions (e.g. nullptr not found 455 // as it's a C++11 feature). Currently lldb evaluates C++14 as C++11 (see 456 // two lines below) so we decide to be consistent with that, but this could 457 // be re-evaluated in the future. 458 lang_opts.CPlusPlus11 = true; 459 break; 460 case lldb::eLanguageTypeC_plus_plus: 461 case lldb::eLanguageTypeC_plus_plus_11: 462 case lldb::eLanguageTypeC_plus_plus_14: 463 lang_opts.CPlusPlus11 = true; 464 m_compiler->getHeaderSearchOpts().UseLibcxx = true; 465 LLVM_FALLTHROUGH; 466 case lldb::eLanguageTypeC_plus_plus_03: 467 lang_opts.CPlusPlus = true; 468 if (process_sp) 469 lang_opts.ObjC = 470 process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC) != nullptr; 471 break; 472 case lldb::eLanguageTypeObjC_plus_plus: 473 case lldb::eLanguageTypeUnknown: 474 default: 475 lang_opts.ObjC = true; 476 lang_opts.CPlusPlus = true; 477 lang_opts.CPlusPlus11 = true; 478 m_compiler->getHeaderSearchOpts().UseLibcxx = true; 479 break; 480 } 481 482 lang_opts.Bool = true; 483 lang_opts.WChar = true; 484 lang_opts.Blocks = true; 485 lang_opts.DebuggerSupport = 486 true; // Features specifically for debugger clients 487 if (expr.DesiredResultType() == Expression::eResultTypeId) 488 lang_opts.DebuggerCastResultToId = true; 489 490 lang_opts.CharIsSigned = ArchSpec(m_compiler->getTargetOpts().Triple.c_str()) 491 .CharIsSignedByDefault(); 492 493 // Spell checking is a nice feature, but it ends up completing a lot of types 494 // that we didn't strictly speaking need to complete. As a result, we spend a 495 // long time parsing and importing debug information. 496 lang_opts.SpellChecking = false; 497 498 auto *clang_expr = dyn_cast<ClangUserExpression>(&m_expr); 499 if (clang_expr && clang_expr->DidImportCxxModules()) { 500 LLDB_LOG(log, "Adding lang options for importing C++ modules"); 501 502 lang_opts.Modules = true; 503 // We want to implicitly build modules. 504 lang_opts.ImplicitModules = true; 505 // To automatically import all submodules when we import 'std'. 506 lang_opts.ModulesLocalVisibility = false; 507 508 // We use the @import statements, so we need this: 509 // FIXME: We could use the modules-ts, but that currently doesn't work. 510 lang_opts.ObjC = true; 511 512 // Options we need to parse libc++ code successfully. 513 // FIXME: We should ask the driver for the appropriate default flags. 514 lang_opts.GNUMode = true; 515 lang_opts.GNUKeywords = true; 516 lang_opts.DoubleSquareBracketAttributes = true; 517 lang_opts.CPlusPlus11 = true; 518 519 // The Darwin libc expects this macro to be set. 520 lang_opts.GNUCVersion = 40201; 521 522 SetupModuleHeaderPaths(m_compiler.get(), m_include_directories, 523 target_sp); 524 } 525 526 if (process_sp && lang_opts.ObjC) { 527 if (auto *runtime = ObjCLanguageRuntime::Get(*process_sp)) { 528 if (runtime->GetRuntimeVersion() == 529 ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2) 530 lang_opts.ObjCRuntime.set(ObjCRuntime::MacOSX, VersionTuple(10, 7)); 531 else 532 lang_opts.ObjCRuntime.set(ObjCRuntime::FragileMacOSX, 533 VersionTuple(10, 7)); 534 535 if (runtime->HasNewLiteralsAndIndexing()) 536 lang_opts.DebuggerObjCLiteral = true; 537 } 538 } 539 540 lang_opts.ThreadsafeStatics = false; 541 lang_opts.AccessControl = false; // Debuggers get universal access 542 lang_opts.DollarIdents = true; // $ indicates a persistent variable name 543 // We enable all builtin functions beside the builtins from libc/libm (e.g. 544 // 'fopen'). Those libc functions are already correctly handled by LLDB, and 545 // additionally enabling them as expandable builtins is breaking Clang. 546 lang_opts.NoBuiltin = true; 547 548 // Set CodeGen options 549 m_compiler->getCodeGenOpts().EmitDeclMetadata = true; 550 m_compiler->getCodeGenOpts().InstrumentFunctions = false; 551 m_compiler->getCodeGenOpts().setFramePointer( 552 CodeGenOptions::FramePointerKind::All); 553 if (generate_debug_info) 554 m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo); 555 else 556 m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::NoDebugInfo); 557 558 // Disable some warnings. 559 m_compiler->getDiagnostics().setSeverityForGroup( 560 clang::diag::Flavor::WarningOrError, "unused-value", 561 clang::diag::Severity::Ignored, SourceLocation()); 562 m_compiler->getDiagnostics().setSeverityForGroup( 563 clang::diag::Flavor::WarningOrError, "odr", 564 clang::diag::Severity::Ignored, SourceLocation()); 565 566 // Inform the target of the language options 567 // 568 // FIXME: We shouldn't need to do this, the target should be immutable once 569 // created. This complexity should be lifted elsewhere. 570 m_compiler->getTarget().adjust(m_compiler->getLangOpts()); 571 572 // 6. Set up the diagnostic buffer for reporting errors 573 574 auto diag_mgr = new ClangDiagnosticManagerAdapter( 575 m_compiler->getDiagnostics().getDiagnosticOptions()); 576 m_compiler->getDiagnostics().setClient(diag_mgr); 577 578 // 7. Set up the source management objects inside the compiler 579 m_compiler->createFileManager(); 580 if (!m_compiler->hasSourceManager()) 581 m_compiler->createSourceManager(m_compiler->getFileManager()); 582 m_compiler->createPreprocessor(TU_Complete); 583 584 if (ClangModulesDeclVendor *decl_vendor = 585 target_sp->GetClangModulesDeclVendor()) { 586 if (auto *clang_persistent_vars = llvm::cast<ClangPersistentVariables>( 587 target_sp->GetPersistentExpressionStateForLanguage( 588 lldb::eLanguageTypeC))) { 589 std::unique_ptr<PPCallbacks> pp_callbacks( 590 new LLDBPreprocessorCallbacks(*decl_vendor, *clang_persistent_vars, 591 m_compiler->getSourceManager())); 592 m_pp_callbacks = 593 static_cast<LLDBPreprocessorCallbacks *>(pp_callbacks.get()); 594 m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks)); 595 } 596 } 597 598 // 8. Most of this we get from the CompilerInstance, but we also want to give 599 // the context an ExternalASTSource. 600 601 auto &PP = m_compiler->getPreprocessor(); 602 auto &builtin_context = PP.getBuiltinInfo(); 603 builtin_context.initializeBuiltins(PP.getIdentifierTable(), 604 m_compiler->getLangOpts()); 605 606 m_compiler->createASTContext(); 607 clang::ASTContext &ast_context = m_compiler->getASTContext(); 608 609 m_ast_context.reset(new ClangASTContext(ast_context)); 610 611 std::string module_name("$__lldb_module"); 612 613 m_llvm_context.reset(new LLVMContext()); 614 m_code_generator.reset(CreateLLVMCodeGen( 615 m_compiler->getDiagnostics(), module_name, 616 m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(), 617 m_compiler->getCodeGenOpts(), *m_llvm_context)); 618} 619 620ClangExpressionParser::~ClangExpressionParser() {} 621 622namespace { 623 624/// \class CodeComplete 625/// 626/// A code completion consumer for the clang Sema that is responsible for 627/// creating the completion suggestions when a user requests completion 628/// of an incomplete `expr` invocation. 629class CodeComplete : public CodeCompleteConsumer { 630 CodeCompletionTUInfo m_info; 631 632 std::string m_expr; 633 unsigned m_position = 0; 634 CompletionRequest &m_request; 635 /// The printing policy we use when printing declarations for our completion 636 /// descriptions. 637 clang::PrintingPolicy m_desc_policy; 638 639 /// Returns true if the given character can be used in an identifier. 640 /// This also returns true for numbers because for completion we usually 641 /// just iterate backwards over iterators. 642 /// 643 /// Note: lldb uses '$' in its internal identifiers, so we also allow this. 644 static bool IsIdChar(char c) { 645 return c == '_' || std::isalnum(c) || c == '$'; 646 } 647 648 /// Returns true if the given character is used to separate arguments 649 /// in the command line of lldb. 650 static bool IsTokenSeparator(char c) { return c == ' ' || c == '\t'; } 651 652 /// Drops all tokens in front of the expression that are unrelated for 653 /// the completion of the cmd line. 'unrelated' means here that the token 654 /// is not interested for the lldb completion API result. 655 StringRef dropUnrelatedFrontTokens(StringRef cmd) { 656 if (cmd.empty()) 657 return cmd; 658 659 // If we are at the start of a word, then all tokens are unrelated to 660 // the current completion logic. 661 if (IsTokenSeparator(cmd.back())) 662 return StringRef(); 663 664 // Remove all previous tokens from the string as they are unrelated 665 // to completing the current token. 666 StringRef to_remove = cmd; 667 while (!to_remove.empty() && !IsTokenSeparator(to_remove.back())) { 668 to_remove = to_remove.drop_back(); 669 } 670 cmd = cmd.drop_front(to_remove.size()); 671 672 return cmd; 673 } 674 675 /// Removes the last identifier token from the given cmd line. 676 StringRef removeLastToken(StringRef cmd) { 677 while (!cmd.empty() && IsIdChar(cmd.back())) { 678 cmd = cmd.drop_back(); 679 } 680 return cmd; 681 } 682 683 /// Attemps to merge the given completion from the given position into the 684 /// existing command. Returns the completion string that can be returned to 685 /// the lldb completion API. 686 std::string mergeCompletion(StringRef existing, unsigned pos, 687 StringRef completion) { 688 StringRef existing_command = existing.substr(0, pos); 689 // We rewrite the last token with the completion, so let's drop that 690 // token from the command. 691 existing_command = removeLastToken(existing_command); 692 // We also should remove all previous tokens from the command as they 693 // would otherwise be added to the completion that already has the 694 // completion. 695 existing_command = dropUnrelatedFrontTokens(existing_command); 696 return existing_command.str() + completion.str(); 697 } 698 699public: 700 /// Constructs a CodeComplete consumer that can be attached to a Sema. 701 /// 702 /// \param[out] expr 703 /// The whole expression string that we are currently parsing. This 704 /// string needs to be equal to the input the user typed, and NOT the 705 /// final code that Clang is parsing. 706 /// \param[out] position 707 /// The character position of the user cursor in the `expr` parameter. 708 /// 709 CodeComplete(CompletionRequest &request, clang::LangOptions ops, 710 std::string expr, unsigned position) 711 : CodeCompleteConsumer(CodeCompleteOptions()), 712 m_info(std::make_shared<GlobalCodeCompletionAllocator>()), m_expr(expr), 713 m_position(position), m_request(request), m_desc_policy(ops) { 714 715 // Ensure that the printing policy is producing a description that is as 716 // short as possible. 717 m_desc_policy.SuppressScope = true; 718 m_desc_policy.SuppressTagKeyword = true; 719 m_desc_policy.FullyQualifiedName = false; 720 m_desc_policy.TerseOutput = true; 721 m_desc_policy.IncludeNewlines = false; 722 m_desc_policy.UseVoidForZeroParams = false; 723 m_desc_policy.Bool = true; 724 } 725 726 /// Deregisters and destroys this code-completion consumer. 727 ~CodeComplete() override {} 728 729 /// \name Code-completion filtering 730 /// Check if the result should be filtered out. 731 bool isResultFilteredOut(StringRef Filter, 732 CodeCompletionResult Result) override { 733 // This code is mostly copied from CodeCompleteConsumer. 734 switch (Result.Kind) { 735 case CodeCompletionResult::RK_Declaration: 736 return !( 737 Result.Declaration->getIdentifier() && 738 Result.Declaration->getIdentifier()->getName().startswith(Filter)); 739 case CodeCompletionResult::RK_Keyword: 740 return !StringRef(Result.Keyword).startswith(Filter); 741 case CodeCompletionResult::RK_Macro: 742 return !Result.Macro->getName().startswith(Filter); 743 case CodeCompletionResult::RK_Pattern: 744 return !StringRef(Result.Pattern->getAsString()).startswith(Filter); 745 } 746 // If we trigger this assert or the above switch yields a warning, then 747 // CodeCompletionResult has been enhanced with more kinds of completion 748 // results. Expand the switch above in this case. 749 assert(false && "Unknown completion result type?"); 750 // If we reach this, then we should just ignore whatever kind of unknown 751 // result we got back. We probably can't turn it into any kind of useful 752 // completion suggestion with the existing code. 753 return true; 754 } 755 756 /// \name Code-completion callbacks 757 /// Process the finalized code-completion results. 758 void ProcessCodeCompleteResults(Sema &SemaRef, CodeCompletionContext Context, 759 CodeCompletionResult *Results, 760 unsigned NumResults) override { 761 762 // The Sema put the incomplete token we try to complete in here during 763 // lexing, so we need to retrieve it here to know what we are completing. 764 StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter(); 765 766 // Iterate over all the results. Filter out results we don't want and 767 // process the rest. 768 for (unsigned I = 0; I != NumResults; ++I) { 769 // Filter the results with the information from the Sema. 770 if (!Filter.empty() && isResultFilteredOut(Filter, Results[I])) 771 continue; 772 773 CodeCompletionResult &R = Results[I]; 774 std::string ToInsert; 775 std::string Description; 776 // Handle the different completion kinds that come from the Sema. 777 switch (R.Kind) { 778 case CodeCompletionResult::RK_Declaration: { 779 const NamedDecl *D = R.Declaration; 780 ToInsert = R.Declaration->getNameAsString(); 781 // If we have a function decl that has no arguments we want to 782 // complete the empty parantheses for the user. If the function has 783 // arguments, we at least complete the opening bracket. 784 if (const FunctionDecl *F = dyn_cast<FunctionDecl>(D)) { 785 if (F->getNumParams() == 0) 786 ToInsert += "()"; 787 else 788 ToInsert += "("; 789 raw_string_ostream OS(Description); 790 F->print(OS, m_desc_policy, false); 791 OS.flush(); 792 } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) { 793 Description = V->getType().getAsString(m_desc_policy); 794 } else if (const FieldDecl *F = dyn_cast<FieldDecl>(D)) { 795 Description = F->getType().getAsString(m_desc_policy); 796 } else if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) { 797 // If we try to complete a namespace, then we can directly append 798 // the '::'. 799 if (!N->isAnonymousNamespace()) 800 ToInsert += "::"; 801 } 802 break; 803 } 804 case CodeCompletionResult::RK_Keyword: 805 ToInsert = R.Keyword; 806 break; 807 case CodeCompletionResult::RK_Macro: 808 ToInsert = R.Macro->getName().str(); 809 break; 810 case CodeCompletionResult::RK_Pattern: 811 ToInsert = R.Pattern->getTypedText(); 812 break; 813 } 814 // At this point all information is in the ToInsert string. 815 816 // We also filter some internal lldb identifiers here. The user 817 // shouldn't see these. 818 if (StringRef(ToInsert).startswith("$__lldb_")) 819 continue; 820 if (!ToInsert.empty()) { 821 // Merge the suggested Token into the existing command line to comply 822 // with the kind of result the lldb API expects. 823 std::string CompletionSuggestion = 824 mergeCompletion(m_expr, m_position, ToInsert); 825 m_request.AddCompletion(CompletionSuggestion, Description); 826 } 827 } 828 } 829 830 /// \param S the semantic-analyzer object for which code-completion is being 831 /// done. 832 /// 833 /// \param CurrentArg the index of the current argument. 834 /// 835 /// \param Candidates an array of overload candidates. 836 /// 837 /// \param NumCandidates the number of overload candidates 838 void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 839 OverloadCandidate *Candidates, 840 unsigned NumCandidates, 841 SourceLocation OpenParLoc) override { 842 // At the moment we don't filter out any overloaded candidates. 843 } 844 845 CodeCompletionAllocator &getAllocator() override { 846 return m_info.getAllocator(); 847 } 848 849 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return m_info; } 850}; 851} // namespace 852 853bool ClangExpressionParser::Complete(CompletionRequest &request, unsigned line, 854 unsigned pos, unsigned typed_pos) { 855 DiagnosticManager mgr; 856 // We need the raw user expression here because that's what the CodeComplete 857 // class uses to provide completion suggestions. 858 // However, the `Text` method only gives us the transformed expression here. 859 // To actually get the raw user input here, we have to cast our expression to 860 // the LLVMUserExpression which exposes the right API. This should never fail 861 // as we always have a ClangUserExpression whenever we call this. 862 ClangUserExpression *llvm_expr = cast<ClangUserExpression>(&m_expr); 863 CodeComplete CC(request, m_compiler->getLangOpts(), llvm_expr->GetUserText(), 864 typed_pos); 865 // We don't need a code generator for parsing. 866 m_code_generator.reset(); 867 // Start parsing the expression with our custom code completion consumer. 868 ParseInternal(mgr, &CC, line, pos); 869 return true; 870} 871 872unsigned ClangExpressionParser::Parse(DiagnosticManager &diagnostic_manager) { 873 return ParseInternal(diagnostic_manager); 874} 875 876unsigned 877ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager, 878 CodeCompleteConsumer *completion_consumer, 879 unsigned completion_line, 880 unsigned completion_column) { 881 ClangDiagnosticManagerAdapter *adapter = 882 static_cast<ClangDiagnosticManagerAdapter *>( 883 m_compiler->getDiagnostics().getClient()); 884 auto diag_buf = adapter->GetPassthrough(); 885 886 adapter->ResetManager(&diagnostic_manager); 887 888 const char *expr_text = m_expr.Text(); 889 890 clang::SourceManager &source_mgr = m_compiler->getSourceManager(); 891 bool created_main_file = false; 892 893 // Clang wants to do completion on a real file known by Clang's file manager, 894 // so we have to create one to make this work. 895 // TODO: We probably could also simulate to Clang's file manager that there 896 // is a real file that contains our code. 897 bool should_create_file = completion_consumer != nullptr; 898 899 // We also want a real file on disk if we generate full debug info. 900 should_create_file |= m_compiler->getCodeGenOpts().getDebugInfo() == 901 codegenoptions::FullDebugInfo; 902 903 if (should_create_file) { 904 int temp_fd = -1; 905 llvm::SmallString<128> result_path; 906 if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) { 907 tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr"); 908 std::string temp_source_path = tmpdir_file_spec.GetPath(); 909 llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path); 910 } else { 911 llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path); 912 } 913 914 if (temp_fd != -1) { 915 lldb_private::NativeFile file(temp_fd, File::eOpenOptionWrite, true); 916 const size_t expr_text_len = strlen(expr_text); 917 size_t bytes_written = expr_text_len; 918 if (file.Write(expr_text, bytes_written).Success()) { 919 if (bytes_written == expr_text_len) { 920 file.Close(); 921 if (auto fileEntry = 922 m_compiler->getFileManager().getFile(result_path)) { 923 source_mgr.setMainFileID(source_mgr.createFileID( 924 *fileEntry, 925 SourceLocation(), SrcMgr::C_User)); 926 created_main_file = true; 927 } 928 } 929 } 930 } 931 } 932 933 if (!created_main_file) { 934 std::unique_ptr<MemoryBuffer> memory_buffer = 935 MemoryBuffer::getMemBufferCopy(expr_text, m_filename); 936 source_mgr.setMainFileID(source_mgr.createFileID(std::move(memory_buffer))); 937 } 938 939 diag_buf->BeginSourceFile(m_compiler->getLangOpts(), 940 &m_compiler->getPreprocessor()); 941 942 ClangExpressionHelper *type_system_helper = 943 dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper()); 944 945 // If we want to parse for code completion, we need to attach our code 946 // completion consumer to the Sema and specify a completion position. 947 // While parsing the Sema will call this consumer with the provided 948 // completion suggestions. 949 if (completion_consumer) { 950 auto main_file = source_mgr.getFileEntryForID(source_mgr.getMainFileID()); 951 auto &PP = m_compiler->getPreprocessor(); 952 // Lines and columns start at 1 in Clang, but code completion positions are 953 // indexed from 0, so we need to add 1 to the line and column here. 954 ++completion_line; 955 ++completion_column; 956 PP.SetCodeCompletionPoint(main_file, completion_line, completion_column); 957 } 958 959 ASTConsumer *ast_transformer = 960 type_system_helper->ASTTransformer(m_code_generator.get()); 961 962 std::unique_ptr<clang::ASTConsumer> Consumer; 963 if (ast_transformer) { 964 Consumer.reset(new ASTConsumerForwarder(ast_transformer)); 965 } else if (m_code_generator) { 966 Consumer.reset(new ASTConsumerForwarder(m_code_generator.get())); 967 } else { 968 Consumer.reset(new ASTConsumer()); 969 } 970 971 clang::ASTContext &ast_context = m_compiler->getASTContext(); 972 973 m_compiler->setSema(new Sema(m_compiler->getPreprocessor(), ast_context, 974 *Consumer, TU_Complete, completion_consumer)); 975 m_compiler->setASTConsumer(std::move(Consumer)); 976 977 if (ast_context.getLangOpts().Modules) { 978 m_compiler->createASTReader(); 979 m_ast_context->setSema(&m_compiler->getSema()); 980 } 981 982 ClangExpressionDeclMap *decl_map = type_system_helper->DeclMap(); 983 if (decl_map) { 984 decl_map->InstallCodeGenerator(&m_compiler->getASTConsumer()); 985 986 clang::ExternalASTSource *ast_source = decl_map->CreateProxy(); 987 988 if (ast_context.getExternalSource()) { 989 auto module_wrapper = 990 new ExternalASTSourceWrapper(ast_context.getExternalSource()); 991 992 auto ast_source_wrapper = new ExternalASTSourceWrapper(ast_source); 993 994 auto multiplexer = 995 new SemaSourceWithPriorities(*module_wrapper, *ast_source_wrapper); 996 IntrusiveRefCntPtr<ExternalASTSource> Source(multiplexer); 997 ast_context.setExternalSource(Source); 998 } else { 999 ast_context.setExternalSource(ast_source); 1000 } 1001 decl_map->InstallASTContext(*m_ast_context); 1002 } 1003 1004 // Check that the ASTReader is properly attached to ASTContext and Sema. 1005 if (ast_context.getLangOpts().Modules) { 1006 assert(m_compiler->getASTContext().getExternalSource() && 1007 "ASTContext doesn't know about the ASTReader?"); 1008 assert(m_compiler->getSema().getExternalSource() && 1009 "Sema doesn't know about the ASTReader?"); 1010 } 1011 1012 { 1013 llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema( 1014 &m_compiler->getSema()); 1015 ParseAST(m_compiler->getSema(), false, false); 1016 } 1017 1018 // Make sure we have no pointer to the Sema we are about to destroy. 1019 if (ast_context.getLangOpts().Modules) 1020 m_ast_context->setSema(nullptr); 1021 // Destroy the Sema. This is necessary because we want to emulate the 1022 // original behavior of ParseAST (which also destroys the Sema after parsing). 1023 m_compiler->setSema(nullptr); 1024 1025 diag_buf->EndSourceFile(); 1026 1027 unsigned num_errors = diag_buf->getNumErrors(); 1028 1029 if (m_pp_callbacks && m_pp_callbacks->hasErrors()) { 1030 num_errors++; 1031 diagnostic_manager.PutString(eDiagnosticSeverityError, 1032 "while importing modules:"); 1033 diagnostic_manager.AppendMessageToDiagnostic( 1034 m_pp_callbacks->getErrorString()); 1035 } 1036 1037 if (!num_errors) { 1038 type_system_helper->CommitPersistentDecls(); 1039 } 1040 1041 adapter->ResetManager(); 1042 1043 return num_errors; 1044} 1045 1046std::string 1047ClangExpressionParser::GetClangTargetABI(const ArchSpec &target_arch) { 1048 std::string abi; 1049 1050 if (target_arch.IsMIPS()) { 1051 switch (target_arch.GetFlags() & ArchSpec::eMIPSABI_mask) { 1052 case ArchSpec::eMIPSABI_N64: 1053 abi = "n64"; 1054 break; 1055 case ArchSpec::eMIPSABI_N32: 1056 abi = "n32"; 1057 break; 1058 case ArchSpec::eMIPSABI_O32: 1059 abi = "o32"; 1060 break; 1061 default: 1062 break; 1063 } 1064 } 1065 return abi; 1066} 1067 1068bool ClangExpressionParser::RewriteExpression( 1069 DiagnosticManager &diagnostic_manager) { 1070 clang::SourceManager &source_manager = m_compiler->getSourceManager(); 1071 clang::edit::EditedSource editor(source_manager, m_compiler->getLangOpts(), 1072 nullptr); 1073 clang::edit::Commit commit(editor); 1074 clang::Rewriter rewriter(source_manager, m_compiler->getLangOpts()); 1075 1076 class RewritesReceiver : public edit::EditsReceiver { 1077 Rewriter &rewrite; 1078 1079 public: 1080 RewritesReceiver(Rewriter &in_rewrite) : rewrite(in_rewrite) {} 1081 1082 void insert(SourceLocation loc, StringRef text) override { 1083 rewrite.InsertText(loc, text); 1084 } 1085 void replace(CharSourceRange range, StringRef text) override { 1086 rewrite.ReplaceText(range.getBegin(), rewrite.getRangeSize(range), text); 1087 } 1088 }; 1089 1090 RewritesReceiver rewrites_receiver(rewriter); 1091 1092 const DiagnosticList &diagnostics = diagnostic_manager.Diagnostics(); 1093 size_t num_diags = diagnostics.size(); 1094 if (num_diags == 0) 1095 return false; 1096 1097 for (const auto &diag : diagnostic_manager.Diagnostics()) { 1098 const auto *diagnostic = llvm::dyn_cast<ClangDiagnostic>(diag.get()); 1099 if (diagnostic && diagnostic->HasFixIts()) { 1100 for (const FixItHint &fixit : diagnostic->FixIts()) { 1101 // This is cobbed from clang::Rewrite::FixItRewriter. 1102 if (fixit.CodeToInsert.empty()) { 1103 if (fixit.InsertFromRange.isValid()) { 1104 commit.insertFromRange(fixit.RemoveRange.getBegin(), 1105 fixit.InsertFromRange, /*afterToken=*/false, 1106 fixit.BeforePreviousInsertions); 1107 } else 1108 commit.remove(fixit.RemoveRange); 1109 } else { 1110 if (fixit.RemoveRange.isTokenRange() || 1111 fixit.RemoveRange.getBegin() != fixit.RemoveRange.getEnd()) 1112 commit.replace(fixit.RemoveRange, fixit.CodeToInsert); 1113 else 1114 commit.insert(fixit.RemoveRange.getBegin(), fixit.CodeToInsert, 1115 /*afterToken=*/false, fixit.BeforePreviousInsertions); 1116 } 1117 } 1118 } 1119 } 1120 1121 // FIXME - do we want to try to propagate specific errors here? 1122 if (!commit.isCommitable()) 1123 return false; 1124 else if (!editor.commit(commit)) 1125 return false; 1126 1127 // Now play all the edits, and stash the result in the diagnostic manager. 1128 editor.applyRewrites(rewrites_receiver); 1129 RewriteBuffer &main_file_buffer = 1130 rewriter.getEditBuffer(source_manager.getMainFileID()); 1131 1132 std::string fixed_expression; 1133 llvm::raw_string_ostream out_stream(fixed_expression); 1134 1135 main_file_buffer.write(out_stream); 1136 out_stream.flush(); 1137 diagnostic_manager.SetFixedExpression(fixed_expression); 1138 1139 return true; 1140} 1141 1142static bool FindFunctionInModule(ConstString &mangled_name, 1143 llvm::Module *module, const char *orig_name) { 1144 for (const auto &func : module->getFunctionList()) { 1145 const StringRef &name = func.getName(); 1146 if (name.find(orig_name) != StringRef::npos) { 1147 mangled_name.SetString(name); 1148 return true; 1149 } 1150 } 1151 1152 return false; 1153} 1154 1155lldb_private::Status ClangExpressionParser::PrepareForExecution( 1156 lldb::addr_t &func_addr, lldb::addr_t &func_end, 1157 lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx, 1158 bool &can_interpret, ExecutionPolicy execution_policy) { 1159 func_addr = LLDB_INVALID_ADDRESS; 1160 func_end = LLDB_INVALID_ADDRESS; 1161 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1162 1163 lldb_private::Status err; 1164 1165 std::unique_ptr<llvm::Module> llvm_module_up( 1166 m_code_generator->ReleaseModule()); 1167 1168 if (!llvm_module_up) { 1169 err.SetErrorToGenericError(); 1170 err.SetErrorString("IR doesn't contain a module"); 1171 return err; 1172 } 1173 1174 ConstString function_name; 1175 1176 if (execution_policy != eExecutionPolicyTopLevel) { 1177 // Find the actual name of the function (it's often mangled somehow) 1178 1179 if (!FindFunctionInModule(function_name, llvm_module_up.get(), 1180 m_expr.FunctionName())) { 1181 err.SetErrorToGenericError(); 1182 err.SetErrorStringWithFormat("Couldn't find %s() in the module", 1183 m_expr.FunctionName()); 1184 return err; 1185 } else { 1186 LLDB_LOGF(log, "Found function %s for %s", function_name.AsCString(), 1187 m_expr.FunctionName()); 1188 } 1189 } 1190 1191 SymbolContext sc; 1192 1193 if (lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP()) { 1194 sc = frame_sp->GetSymbolContext(lldb::eSymbolContextEverything); 1195 } else if (lldb::TargetSP target_sp = exe_ctx.GetTargetSP()) { 1196 sc.target_sp = target_sp; 1197 } 1198 1199 LLVMUserExpression::IRPasses custom_passes; 1200 { 1201 auto lang = m_expr.Language(); 1202 LLDB_LOGF(log, "%s - Current expression language is %s\n", __FUNCTION__, 1203 Language::GetNameForLanguageType(lang)); 1204 lldb::ProcessSP process_sp = exe_ctx.GetProcessSP(); 1205 if (process_sp && lang != lldb::eLanguageTypeUnknown) { 1206 auto runtime = process_sp->GetLanguageRuntime(lang); 1207 if (runtime) 1208 runtime->GetIRPasses(custom_passes); 1209 } 1210 } 1211 1212 if (custom_passes.EarlyPasses) { 1213 LLDB_LOGF(log, 1214 "%s - Running Early IR Passes from LanguageRuntime on " 1215 "expression module '%s'", 1216 __FUNCTION__, m_expr.FunctionName()); 1217 1218 custom_passes.EarlyPasses->run(*llvm_module_up); 1219 } 1220 1221 execution_unit_sp = std::make_shared<IRExecutionUnit>( 1222 m_llvm_context, // handed off here 1223 llvm_module_up, // handed off here 1224 function_name, exe_ctx.GetTargetSP(), sc, 1225 m_compiler->getTargetOpts().Features); 1226 1227 ClangExpressionHelper *type_system_helper = 1228 dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper()); 1229 ClangExpressionDeclMap *decl_map = 1230 type_system_helper->DeclMap(); // result can be NULL 1231 1232 if (decl_map) { 1233 Target *target = exe_ctx.GetTargetPtr(); 1234 auto &error_stream = target->GetDebugger().GetErrorStream(); 1235 IRForTarget ir_for_target(decl_map, m_expr.NeedsVariableResolution(), 1236 *execution_unit_sp, error_stream, 1237 function_name.AsCString()); 1238 1239 bool ir_can_run = 1240 ir_for_target.runOnModule(*execution_unit_sp->GetModule()); 1241 1242 if (!ir_can_run) { 1243 err.SetErrorString( 1244 "The expression could not be prepared to run in the target"); 1245 return err; 1246 } 1247 1248 Process *process = exe_ctx.GetProcessPtr(); 1249 1250 if (execution_policy != eExecutionPolicyAlways && 1251 execution_policy != eExecutionPolicyTopLevel) { 1252 lldb_private::Status interpret_error; 1253 1254 bool interpret_function_calls = 1255 !process ? false : process->CanInterpretFunctionCalls(); 1256 can_interpret = IRInterpreter::CanInterpret( 1257 *execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(), 1258 interpret_error, interpret_function_calls); 1259 1260 if (!can_interpret && execution_policy == eExecutionPolicyNever) { 1261 err.SetErrorStringWithFormat( 1262 "Can't evaluate the expression without a running target due to: %s", 1263 interpret_error.AsCString()); 1264 return err; 1265 } 1266 } 1267 1268 if (!process && execution_policy == eExecutionPolicyAlways) { 1269 err.SetErrorString("Expression needed to run in the target, but the " 1270 "target can't be run"); 1271 return err; 1272 } 1273 1274 if (!process && execution_policy == eExecutionPolicyTopLevel) { 1275 err.SetErrorString("Top-level code needs to be inserted into a runnable " 1276 "target, but the target can't be run"); 1277 return err; 1278 } 1279 1280 if (execution_policy == eExecutionPolicyAlways || 1281 (execution_policy != eExecutionPolicyTopLevel && !can_interpret)) { 1282 if (m_expr.NeedsValidation() && process) { 1283 if (!process->GetDynamicCheckers()) { 1284 ClangDynamicCheckerFunctions *dynamic_checkers = 1285 new ClangDynamicCheckerFunctions(); 1286 1287 DiagnosticManager install_diagnostics; 1288 1289 if (!dynamic_checkers->Install(install_diagnostics, exe_ctx)) { 1290 if (install_diagnostics.Diagnostics().size()) 1291 err.SetErrorString(install_diagnostics.GetString().c_str()); 1292 else 1293 err.SetErrorString("couldn't install checkers, unknown error"); 1294 1295 return err; 1296 } 1297 1298 process->SetDynamicCheckers(dynamic_checkers); 1299 1300 LLDB_LOGF(log, "== [ClangExpressionParser::PrepareForExecution] " 1301 "Finished installing dynamic checkers =="); 1302 } 1303 1304 if (auto *checker_funcs = llvm::dyn_cast<ClangDynamicCheckerFunctions>( 1305 process->GetDynamicCheckers())) { 1306 IRDynamicChecks ir_dynamic_checks(*checker_funcs, 1307 function_name.AsCString()); 1308 1309 llvm::Module *module = execution_unit_sp->GetModule(); 1310 if (!module || !ir_dynamic_checks.runOnModule(*module)) { 1311 err.SetErrorToGenericError(); 1312 err.SetErrorString("Couldn't add dynamic checks to the expression"); 1313 return err; 1314 } 1315 1316 if (custom_passes.LatePasses) { 1317 LLDB_LOGF(log, 1318 "%s - Running Late IR Passes from LanguageRuntime on " 1319 "expression module '%s'", 1320 __FUNCTION__, m_expr.FunctionName()); 1321 1322 custom_passes.LatePasses->run(*module); 1323 } 1324 } 1325 } 1326 } 1327 1328 if (execution_policy == eExecutionPolicyAlways || 1329 execution_policy == eExecutionPolicyTopLevel || !can_interpret) { 1330 execution_unit_sp->GetRunnableInfo(err, func_addr, func_end); 1331 } 1332 } else { 1333 execution_unit_sp->GetRunnableInfo(err, func_addr, func_end); 1334 } 1335 1336 return err; 1337} 1338 1339lldb_private::Status ClangExpressionParser::RunStaticInitializers( 1340 lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx) { 1341 lldb_private::Status err; 1342 1343 lldbassert(execution_unit_sp.get()); 1344 lldbassert(exe_ctx.HasThreadScope()); 1345 1346 if (!execution_unit_sp.get()) { 1347 err.SetErrorString( 1348 "can't run static initializers for a NULL execution unit"); 1349 return err; 1350 } 1351 1352 if (!exe_ctx.HasThreadScope()) { 1353 err.SetErrorString("can't run static initializers without a thread"); 1354 return err; 1355 } 1356 1357 std::vector<lldb::addr_t> static_initializers; 1358 1359 execution_unit_sp->GetStaticInitializers(static_initializers); 1360 1361 for (lldb::addr_t static_initializer : static_initializers) { 1362 EvaluateExpressionOptions options; 1363 1364 lldb::ThreadPlanSP call_static_initializer(new ThreadPlanCallFunction( 1365 exe_ctx.GetThreadRef(), Address(static_initializer), CompilerType(), 1366 llvm::ArrayRef<lldb::addr_t>(), options)); 1367 1368 DiagnosticManager execution_errors; 1369 lldb::ExpressionResults results = 1370 exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan( 1371 exe_ctx, call_static_initializer, options, execution_errors); 1372 1373 if (results != lldb::eExpressionCompleted) { 1374 err.SetErrorStringWithFormat("couldn't run static initializer: %s", 1375 execution_errors.GetString().c_str()); 1376 return err; 1377 } 1378 } 1379 1380 return err; 1381} 1382