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