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 11 #include "GlobalCompilationDatabase.h" 12 #include "support/Threading.h" 13 #include "llvm/ADT/StringMap.h" 14 #include "llvm/ADT/StringRef.h" 15 #include "llvm/Support/CommandLine.h" 16 #include <deque> 17 #include <optional> 18 #include <string> 19 #include <vector> 20 21 namespace clang { 22 namespace clangd { 23 24 // CommandMangler transforms compile commands from some external source 25 // for use in clangd. This means: 26 // - running the frontend only, stripping args regarding output files etc 27 // - forcing the use of clangd's builtin headers rather than clang's 28 // - resolving argv0 as cc1 expects 29 // - injecting -isysroot flags on mac as the system clang does 30 struct CommandMangler { 31 // Absolute path to clang. 32 std::optional<std::string> ClangPath; 33 // Directory containing builtin headers. 34 std::optional<std::string> ResourceDir; 35 // Root for searching for standard library (passed to -isysroot). 36 std::optional<std::string> Sysroot; 37 SystemIncludeExtractorFn SystemIncludeExtractor; 38 39 // A command-mangler that doesn't know anything about the system. 40 // This is hermetic for unit-tests, but won't work well in production. 41 static CommandMangler forTests(); 42 // Probe the system and build a command-mangler that knows the toolchain. 43 // - try to find clang on $PATH, otherwise fake a path near clangd 44 // - find the resource directory installed near clangd 45 // - on mac, find clang and isysroot by querying the `xcrun` launcher 46 static CommandMangler detect(); 47 48 // `Cmd` may describe compilation of a different file, and will be updated 49 // for parsing `TargetFile`. 50 void operator()(tooling::CompileCommand &Cmd, 51 llvm::StringRef TargetFile) const; 52 53 private: 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 112