clang-tools  16.0.0git
CompileCommands.h
Go to the documentation of this file.
1 //===--- CompileCommands.h - Manipulation of compile flags -------*- 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 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
9 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COMPILECOMMANDS_H
10 
12 #include "support/Threading.h"
13 #include "llvm/ADT/StringMap.h"
14 #include "llvm/ADT/StringRef.h"
15 #include <deque>
16 #include <string>
17 #include <vector>
18 
19 namespace clang {
20 namespace clangd {
21 
22 // CommandMangler transforms compile commands from some external source
23 // for use in clangd. This means:
24 // - running the frontend only, stripping args regarding output files etc
25 // - forcing the use of clangd's builtin headers rather than clang's
26 // - resolving argv0 as cc1 expects
27 // - injecting -isysroot flags on mac as the system clang does
29  // Absolute path to clang.
30  llvm::Optional<std::string> ClangPath;
31  // Directory containing builtin headers.
32  llvm::Optional<std::string> ResourceDir;
33  // Root for searching for standard library (passed to -isysroot).
34  llvm::Optional<std::string> Sysroot;
36 
37  // A command-mangler that doesn't know anything about the system.
38  // This is hermetic for unit-tests, but won't work well in production.
39  static CommandMangler forTests();
40  // Probe the system and build a command-mangler that knows the toolchain.
41  // - try to find clang on $PATH, otherwise fake a path near clangd
42  // - find the resource directory installed near clangd
43  // - on mac, find clang and isysroot by querying the `xcrun` launcher
44  static CommandMangler detect();
45 
46  // `Cmd` may describe compilation of a different file, and will be updated
47  // for parsing `TargetFile`.
48  void operator()(tooling::CompileCommand &Cmd,
49  llvm::StringRef TargetFile) const;
50 
51 private:
52  CommandMangler() = default;
53 
54  Memoize<llvm::StringMap<std::string>> ResolvedDrivers;
55  Memoize<llvm::StringMap<std::string>> ResolvedDriversNoFollow;
56 };
57 
58 // Removes args from a command-line in a semantically-aware way.
59 //
60 // Internally this builds a large (0.5MB) table of clang options on first use.
61 // Both strip() and process() are fairly cheap after that.
62 //
63 // FIXME: this reimplements much of OptTable, it might be nice to expose more.
64 // The table-building strategy may not make sense outside clangd.
65 class ArgStripper {
66 public:
67  ArgStripper() = default;
68  ArgStripper(ArgStripper &&) = default;
69  ArgStripper(const ArgStripper &) = delete;
70  ArgStripper &operator=(ArgStripper &&) = default;
71  ArgStripper &operator=(const ArgStripper &) = delete;
72 
73  // Adds the arg to the set which should be removed.
74  //
75  // Recognized clang flags are stripped semantically. When "-I" is stripped:
76  // - so is its value (either as -Ifoo or -I foo)
77  // - aliases like --include-directory=foo are also stripped
78  // - CL-style /Ifoo will be removed if the args indicate MS-compatible mode
79  // Compile args not recognized as flags are removed literally, except:
80  // - strip("ABC*") will remove any arg with an ABC prefix.
81  //
82  // In either case, the -Xclang prefix will be dropped if present.
83  void strip(llvm::StringRef Arg);
84  // Remove the targets from a compile command, in-place.
85  void process(std::vector<std::string> &Args) const;
86 
87 private:
88  // Deletion rules, to be checked for each arg.
89  struct Rule {
90  llvm::StringRef Text; // Rule applies only if arg begins with Text.
91  unsigned char Modes = 0; // Rule applies only in specified driver modes.
92  uint16_t Priority = 0; // Lower is better.
93  uint16_t ExactArgs = 0; // Num args consumed when Arg == Text.
94  uint16_t PrefixArgs = 0; // Num args consumed when Arg starts with Text.
95  };
96  static llvm::ArrayRef<Rule> rulesFor(llvm::StringRef Arg);
97  const Rule *matchingRule(llvm::StringRef Arg, unsigned Mode,
98  unsigned &ArgCount) const;
99  llvm::SmallVector<Rule> Rules;
100  std::deque<std::string> Storage; // Store strings not found in option table.
101 };
102 
103 // Renders an argv list, with arguments separated by spaces.
104 // Where needed, arguments are "quoted" and escaped.
105 std::string printArgv(llvm::ArrayRef<llvm::StringRef> Args);
106 std::string printArgv(llvm::ArrayRef<std::string> Args);
107 
108 } // namespace clangd
109 } // namespace clang
110 
111 #endif
clang::clangd::printArgv
std::string printArgv(llvm::ArrayRef< llvm::StringRef > Args)
Definition: CompileCommands.cpp:634
clang::clangd::ArgStripper::strip
void strip(llvm::StringRef Arg)
Definition: CompileCommands.cpp:553
clang::clangd::CommandMangler::SystemIncludeExtractor
SystemIncludeExtractorFn SystemIncludeExtractor
Definition: CompileCommands.h:35
clang::clangd::ArgStripper::process
void process(std::vector< std::string > &Args) const
Definition: CompileCommands.cpp:593
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::clangd::SystemIncludeExtractorFn
llvm::unique_function< void(tooling::CompileCommand &, llvm::StringRef) const > SystemIncludeExtractorFn
Extracts system include search path from drivers matching QueryDriverGlobs and adds them to the compi...
Definition: GlobalCompilationDatabase.h:168
clang::clangd::CommandMangler
Definition: CompileCommands.h:28
clang::clangd::CommandMangler::ResourceDir
llvm::Optional< std::string > ResourceDir
Definition: CompileCommands.h:32
clang::clangd::ArgStripper::ArgStripper
ArgStripper()=default
GlobalCompilationDatabase.h
clang::clangd::CommandMangler::detect
static CommandMangler detect()
Definition: CompileCommands.cpp:187
clang::clangd::ArgStripper::operator=
ArgStripper & operator=(ArgStripper &&)=default
Args
llvm::json::Object Args
Definition: Trace.cpp:138
Threading.h
clang::clangd::CommandMangler::Sysroot
llvm::Optional< std::string > Sysroot
Definition: CompileCommands.h:34
clang::clangd::ArgStripper
Definition: CompileCommands.h:65
clang::clangd::CommandMangler::ClangPath
llvm::Optional< std::string > ClangPath
Definition: CompileCommands.h:30
clang::clangd::Memoize
Memoize is a cache to store and reuse computation results based on a key.
Definition: Threading.h:146
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::clangd::CommandMangler::operator()
void operator()(tooling::CompileCommand &Cmd, llvm::StringRef TargetFile) const
Definition: CompileCommands.cpp:197
clang::clangd::CommandMangler::forTests
static CommandMangler forTests()
Definition: CompileCommands.cpp:195