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 "support/Logger.h"
11 #include "clang/Basic/TargetInfo.h"
12 #include "clang/Lex/PreprocessorOptions.h"
13 #include "clang/Serialization/PCHContainerOperations.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/Support/Format.h"
16 #include "llvm/Support/FormatVariadic.h"
17 
18 namespace clang {
19 namespace clangd {
20 
21 void IgnoreDiagnostics::log(DiagnosticsEngine::Level DiagLevel,
22                             const clang::Diagnostic &Info) {
23   // FIXME: format lazily, in case vlog is off.
24   llvm::SmallString<64> Message;
25   Info.FormatDiagnostic(Message);
26 
27   llvm::SmallString<64> Location;
28   if (Info.hasSourceManager() && Info.getLocation().isValid()) {
29     auto &SourceMgr = Info.getSourceManager();
30     auto Loc = SourceMgr.getFileLoc(Info.getLocation());
31     llvm::raw_svector_ostream OS(Location);
32     Loc.print(OS, SourceMgr);
33     OS << ":";
34   }
35 
36   clangd::vlog("Ignored diagnostic. {0}{1}", Location, Message);
37 }
38 
39 void IgnoreDiagnostics::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
40                                          const clang::Diagnostic &Info) {
41   IgnoreDiagnostics::log(DiagLevel, Info);
42 }
43 
44 std::unique_ptr<CompilerInvocation>
45 buildCompilerInvocation(const ParseInputs &Inputs, clang::DiagnosticConsumer &D,
46                         std::vector<std::string> *CC1Args) {
47   std::vector<const char *> ArgStrs;
48   for (const auto &S : Inputs.CompileCommand.CommandLine)
49     ArgStrs.push_back(S.c_str());
50 
51   auto VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
52   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> CommandLineDiagsEngine =
53       CompilerInstance::createDiagnostics(new DiagnosticOptions, &D, false);
54   std::unique_ptr<CompilerInvocation> CI = createInvocationFromCommandLine(
55       ArgStrs, CommandLineDiagsEngine, std::move(VFS),
56       /*ShouldRecoverOnErrors=*/true, CC1Args);
57   if (!CI)
58     return nullptr;
59   // createInvocationFromCommandLine sets DisableFree.
60   CI->getFrontendOpts().DisableFree = false;
61   CI->getLangOpts()->CommentOpts.ParseAllComments = true;
62   CI->getLangOpts()->RetainCommentsFromSystemHeaders = true;
63   // Disable "clang -verify" diagnostics, they are rarely useful in clangd, and
64   // our compiler invocation set-up doesn't seem to work with it (leading
65   // assertions in VerifyDiagnosticConsumer).
66   CI->getDiagnosticOpts().VerifyDiagnostics = false;
67   CI->getDiagnosticOpts().ShowColors = false;
68 
69   // Disable any dependency outputting, we don't want to generate files or write
70   // to stdout/stderr.
71   CI->getDependencyOutputOpts().ShowIncludesDest =
72       ShowIncludesDestination::None;
73   CI->getDependencyOutputOpts().OutputFile.clear();
74   CI->getDependencyOutputOpts().HeaderIncludeOutputFile.clear();
75   CI->getDependencyOutputOpts().DOTOutputFile.clear();
76   CI->getDependencyOutputOpts().ModuleDependencyOutputDir.clear();
77 
78   // Disable any pch generation/usage operations. Since serialized preamble
79   // format is unstable, using an incompatible one might result in unexpected
80   // behaviours, including crashes.
81   CI->getPreprocessorOpts().ImplicitPCHInclude.clear();
82   CI->getPreprocessorOpts().PrecompiledPreambleBytes = {0, false};
83   CI->getPreprocessorOpts().PCHThroughHeader.clear();
84   CI->getPreprocessorOpts().PCHWithHdrStop = false;
85   CI->getPreprocessorOpts().PCHWithHdrStopCreate = false;
86   // Don't crash on `#pragma clang __debug parser_crash`
87   CI->getPreprocessorOpts().DisablePragmaDebugCrash = true;
88 
89   // Always default to raw container format as clangd doesn't registry any other
90   // and clang dies when faced with unknown formats.
91   CI->getHeaderSearchOpts().ModuleFormat =
92       PCHContainerOperations().getRawReader().getFormat().str();
93 
94   CI->getFrontendOpts().Plugins.clear();
95   CI->getFrontendOpts().AddPluginActions.clear();
96   CI->getFrontendOpts().PluginArgs.clear();
97   CI->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
98   CI->getFrontendOpts().ActionName.clear();
99 
100   return CI;
101 }
102 
103 std::unique_ptr<CompilerInstance>
104 prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
105                         const PrecompiledPreamble *Preamble,
106                         std::unique_ptr<llvm::MemoryBuffer> Buffer,
107                         llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
108                         DiagnosticConsumer &DiagsClient) {
109   assert(VFS && "VFS is null");
110   assert(!CI->getPreprocessorOpts().RetainRemappedFileBuffers &&
111          "Setting RetainRemappedFileBuffers to true will cause a memory leak "
112          "of ContentsBuffer");
113 
114   // NOTE: we use Buffer.get() when adding remapped files, so we have to make
115   // sure it will be released if no error is emitted.
116   if (Preamble) {
117     Preamble->OverridePreamble(*CI, VFS, Buffer.get());
118   } else {
119     CI->getPreprocessorOpts().addRemappedFile(
120         CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());
121   }
122 
123   auto Clang = std::make_unique<CompilerInstance>(
124       std::make_shared<PCHContainerOperations>());
125   Clang->setInvocation(std::move(CI));
126   Clang->createDiagnostics(&DiagsClient, false);
127 
128   if (auto VFSWithRemapping = createVFSFromCompilerInvocation(
129           Clang->getInvocation(), Clang->getDiagnostics(), VFS))
130     VFS = VFSWithRemapping;
131   Clang->createFileManager(VFS);
132 
133   if (!Clang->createTarget())
134     return nullptr;
135 
136   // RemappedFileBuffers will handle the lifetime of the Buffer pointer,
137   // release it.
138   Buffer.release();
139   return Clang;
140 }
141 
142 } // namespace clangd
143 } // namespace clang
144