1 //===--- Compiler.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 "Compiler.h" 10 #include "Logger.h" 11 #include "clang/Basic/TargetInfo.h" 12 #include "clang/Lex/PreprocessorOptions.h" 13 #include "clang/Serialization/PCHContainerOperations.h" 14 #include "llvm/Support/Format.h" 15 #include "llvm/Support/FormatVariadic.h" 16 17 namespace clang { 18 namespace clangd { 19 20 void IgnoreDiagnostics::log(DiagnosticsEngine::Level DiagLevel, 21 const clang::Diagnostic &Info) { 22 // FIXME: format lazily, in case vlog is off. 23 llvm::SmallString<64> Message; 24 Info.FormatDiagnostic(Message); 25 26 llvm::SmallString<64> Location; 27 if (Info.hasSourceManager() && Info.getLocation().isValid()) { 28 auto &SourceMgr = Info.getSourceManager(); 29 auto Loc = SourceMgr.getFileLoc(Info.getLocation()); 30 llvm::raw_svector_ostream OS(Location); 31 Loc.print(OS, SourceMgr); 32 OS << ":"; 33 } 34 35 clangd::vlog("Ignored diagnostic. {0}{1}", Location, Message); 36 } 37 38 void IgnoreDiagnostics::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, 39 const clang::Diagnostic &Info) { 40 IgnoreDiagnostics::log(DiagLevel, Info); 41 } 42 43 std::unique_ptr<CompilerInvocation> 44 buildCompilerInvocation(const ParseInputs &Inputs, 45 clang::DiagnosticConsumer &D) { 46 std::vector<const char *> ArgStrs; 47 for (const auto &S : Inputs.CompileCommand.CommandLine) 48 ArgStrs.push_back(S.c_str()); 49 50 if (Inputs.FS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) { 51 log("Couldn't set working directory when creating compiler invocation."); 52 // We proceed anyway, our lit-tests rely on results for non-existing working 53 // dirs. 54 } 55 56 llvm::IntrusiveRefCntPtr<DiagnosticsEngine> CommandLineDiagsEngine = 57 CompilerInstance::createDiagnostics(new DiagnosticOptions, &D, false); 58 std::unique_ptr<CompilerInvocation> CI = createInvocationFromCommandLine( 59 ArgStrs, CommandLineDiagsEngine, Inputs.FS, 60 /*ShouldRecoverOnErrors=*/true); 61 if (!CI) 62 return nullptr; 63 // createInvocationFromCommandLine sets DisableFree. 64 CI->getFrontendOpts().DisableFree = false; 65 CI->getLangOpts()->CommentOpts.ParseAllComments = true; 66 return CI; 67 } 68 69 std::unique_ptr<CompilerInstance> 70 prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI, 71 const PrecompiledPreamble *Preamble, 72 std::unique_ptr<llvm::MemoryBuffer> Buffer, 73 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 74 DiagnosticConsumer &DiagsClient) { 75 assert(VFS && "VFS is null"); 76 assert(!CI->getPreprocessorOpts().RetainRemappedFileBuffers && 77 "Setting RetainRemappedFileBuffers to true will cause a memory leak " 78 "of ContentsBuffer"); 79 80 // NOTE: we use Buffer.get() when adding remapped files, so we have to make 81 // sure it will be released if no error is emitted. 82 if (Preamble) { 83 Preamble->OverridePreamble(*CI, VFS, Buffer.get()); 84 } else { 85 CI->getPreprocessorOpts().addRemappedFile( 86 CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get()); 87 } 88 89 auto Clang = std::make_unique<CompilerInstance>( 90 std::make_shared<PCHContainerOperations>()); 91 Clang->setInvocation(std::move(CI)); 92 Clang->createDiagnostics(&DiagsClient, false); 93 94 if (auto VFSWithRemapping = createVFSFromCompilerInvocation( 95 Clang->getInvocation(), Clang->getDiagnostics(), VFS)) 96 VFS = VFSWithRemapping; 97 Clang->createFileManager(VFS); 98 99 Clang->setTarget(TargetInfo::CreateTargetInfo( 100 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 101 if (!Clang->hasTarget()) 102 return nullptr; 103 104 // RemappedFileBuffers will handle the lifetime of the Buffer pointer, 105 // release it. 106 Buffer.release(); 107 return Clang; 108 } 109 110 } // namespace clangd 111 } // namespace clang 112