clang-tools-extra/clangd/Compiler.cpp

   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
  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 static bool AllowCrashPragmasForTest = false;
  44 void allowCrashPragmasForTest() { AllowCrashPragmasForTest = true; }
  45
  46 void 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`
  70   if (!AllowCrashPragmasForTest)
  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
  94 std::unique_ptr<CompilerInvocation>
  95 buildCompilerInvocation(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
 124   disableUnsupportedOptions(*CI);
 125   return CI;
 126 }
 127
 128 std::unique_ptr<CompilerInstance>
 129 prepareCompilerInstance(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