clang-tools 20.0.0git
Compiler.cpp
Go to the documentation of this file.
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/Frontend/CompilerInvocation.h"
13#include "clang/Lex/PreprocessorOptions.h"
14#include "clang/Serialization/PCHContainerOperations.h"
15#include "llvm/ADT/StringRef.h"
16
17namespace clang {
18namespace clangd {
19
20void 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
38void IgnoreDiagnostics::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
39 const clang::Diagnostic &Info) {
40 IgnoreDiagnostics::log(DiagLevel, Info);
41}
42
43static bool AllowCrashPragmasForTest = false;
45
46void disableUnsupportedOptions(CompilerInvocation &CI) {
47 // Disable "clang -verify" diagnostics, they are rarely useful in clangd, and
48 // our compiler invocation set-up doesn't seem to work with it (leading
49 // assertions in VerifyDiagnosticConsumer).
50 CI.getDiagnosticOpts().VerifyDiagnostics = false;
51 CI.getDiagnosticOpts().ShowColors = false;
52
53 // Disable any dependency outputting, we don't want to generate files or write
54 // to stdout/stderr.
55 CI.getDependencyOutputOpts().ShowIncludesDest = ShowIncludesDestination::None;
56 CI.getDependencyOutputOpts().OutputFile.clear();
57 CI.getDependencyOutputOpts().HeaderIncludeOutputFile.clear();
58 CI.getDependencyOutputOpts().DOTOutputFile.clear();
59 CI.getDependencyOutputOpts().ModuleDependencyOutputDir.clear();
60
61 // Disable any pch generation/usage operations. Since serialized preamble
62 // format is unstable, using an incompatible one might result in unexpected
63 // behaviours, including crashes.
64 CI.getPreprocessorOpts().ImplicitPCHInclude.clear();
65 CI.getPreprocessorOpts().PrecompiledPreambleBytes = {0, false};
66 CI.getPreprocessorOpts().PCHThroughHeader.clear();
67 CI.getPreprocessorOpts().PCHWithHdrStop = false;
68 CI.getPreprocessorOpts().PCHWithHdrStopCreate = false;
69 // Don't crash on `#pragma clang __debug parser_crash`
71 CI.getPreprocessorOpts().DisablePragmaDebugCrash = true;
72
73 // Always default to raw container format as clangd doesn't registry any other
74 // and clang dies when faced with unknown formats.
75 CI.getHeaderSearchOpts().ModuleFormat =
76 PCHContainerOperations().getRawReader().getFormats().front().str();
77
78 CI.getFrontendOpts().Plugins.clear();
79 CI.getFrontendOpts().AddPluginActions.clear();
80 CI.getFrontendOpts().PluginArgs.clear();
81 CI.getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
82 CI.getFrontendOpts().ActionName.clear();
83
84 // These options mostly affect codegen, and aren't relevant to clangd. And
85 // clang will die immediately when these files are not existed.
86 // Disable these uninteresting options to make clangd more robust.
87 CI.getLangOpts().NoSanitizeFiles.clear();
88 CI.getLangOpts().XRayAttrListFiles.clear();
89 CI.getLangOpts().ProfileListFiles.clear();
90 CI.getLangOpts().XRayAlwaysInstrumentFiles.clear();
91 CI.getLangOpts().XRayNeverInstrumentFiles.clear();
92}
93
94std::unique_ptr<CompilerInvocation>
95buildCompilerInvocation(const ParseInputs &Inputs, clang::DiagnosticConsumer &D,
96 std::vector<std::string> *CC1Args) {
97 llvm::ArrayRef<std::string> Argv = Inputs.CompileCommand.CommandLine;
98 if (Argv.empty())
99 return nullptr;
100 std::vector<const char *> ArgStrs;
101 ArgStrs.reserve(Argv.size() + 1);
102 // In asserts builds, CompilerInvocation redundantly reads/parses cc1 args as
103 // a sanity test. This is not useful to clangd, and costs 10% of test time.
104 // To avoid mismatches between assert/production builds, disable it always.
105 ArgStrs = {Argv.front().c_str(), "-Xclang", "-no-round-trip-args"};
106 for (const auto &S : Argv.drop_front())
107 ArgStrs.push_back(S.c_str());
108
109 CreateInvocationOptions CIOpts;
110 CIOpts.VFS = Inputs.TFS->view(Inputs.CompileCommand.Directory);
111 CIOpts.CC1Args = CC1Args;
112 CIOpts.RecoverOnError = true;
113 CIOpts.Diags =
114 CompilerInstance::createDiagnostics(new DiagnosticOptions, &D, false);
115 CIOpts.ProbePrecompiled = false;
116 std::unique_ptr<CompilerInvocation> CI = createInvocation(ArgStrs, CIOpts);
117 if (!CI)
118 return nullptr;
119 // createInvocationFromCommandLine sets DisableFree.
120 CI->getFrontendOpts().DisableFree = false;
121 CI->getLangOpts().CommentOpts.ParseAllComments = true;
122 CI->getLangOpts().RetainCommentsFromSystemHeaders = true;
123
125 return CI;
126}
127
128std::unique_ptr<CompilerInstance>
129prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
130 const PrecompiledPreamble *Preamble,
131 std::unique_ptr<llvm::MemoryBuffer> Buffer,
132 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
133 DiagnosticConsumer &DiagsClient) {
134 assert(VFS && "VFS is null");
135 assert(!CI->getPreprocessorOpts().RetainRemappedFileBuffers &&
136 "Setting RetainRemappedFileBuffers to true will cause a memory leak "
137 "of ContentsBuffer");
138
139 // NOTE: we use Buffer.get() when adding remapped files, so we have to make
140 // sure it will be released if no error is emitted.
141 if (Preamble) {
142 Preamble->OverridePreamble(*CI, VFS, Buffer.get());
143 } else {
144 CI->getPreprocessorOpts().addRemappedFile(
145 CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());
146 }
147
148 auto Clang = std::make_unique<CompilerInstance>(
149 std::make_shared<PCHContainerOperations>());
150 Clang->setInvocation(std::move(CI));
151 Clang->createDiagnostics(&DiagsClient, false);
152
153 if (auto VFSWithRemapping = createVFSFromCompilerInvocation(
154 Clang->getInvocation(), Clang->getDiagnostics(), VFS))
155 VFS = VFSWithRemapping;
156 Clang->createFileManager(VFS);
157
158 if (!Clang->createTarget())
159 return nullptr;
160
161 // RemappedFileBuffers will handle the lifetime of the Buffer pointer,
162 // release it.
163 Buffer.release();
164 return Clang;
165}
166
167} // namespace clangd
168} // namespace clang
std::unique_ptr< CompilerInstance > Clang
SourceLocation Loc
std::unique_ptr< CompilerInvocation > CI
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:160
void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &Info) override
Definition: Compiler.cpp:38
static void log(DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &Info)
Definition: Compiler.cpp:20
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > view(std::nullopt_t CWD) const
Obtain a vfs::FileSystem with an arbitrary initial working directory.
Definition: ThreadsafeFS.h:32
@ Info
An information message.
std::unique_ptr< CompilerInvocation > buildCompilerInvocation(const ParseInputs &Inputs, clang::DiagnosticConsumer &D, std::vector< std::string > *CC1Args)
Builds compiler invocation that could be used to build AST or preamble.
Definition: Compiler.cpp:95
void vlog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:72
std::unique_ptr< CompilerInstance > prepareCompilerInstance(std::unique_ptr< clang::CompilerInvocation > CI, const PrecompiledPreamble *Preamble, std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS, DiagnosticConsumer &DiagsClient)
Definition: Compiler.cpp:129
void allowCrashPragmasForTest()
Respect #pragma clang __debug crash etc, which are usually disabled.
Definition: Compiler.cpp:44
static bool AllowCrashPragmasForTest
Definition: Compiler.cpp:43
void disableUnsupportedOptions(CompilerInvocation &CI)
Clears CI from options that are not supported by clangd, like codegen or plugins.
Definition: Compiler.cpp:46
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Information required to run clang, e.g. to parse AST or do code completion.
Definition: Compiler.h:49
tooling::CompileCommand CompileCommand
Definition: Compiler.h:50
const ThreadsafeFS * TFS
Definition: Compiler.h:51