1 //===- ArgumentsAdjusters.cpp - Command line arguments adjuster -----------===// 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 // This file contains definitions of classes which implement ArgumentsAdjuster 10 // interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Tooling/ArgumentsAdjusters.h" 15 #include "clang/Basic/LLVM.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/StringRef.h" 18 #include <cstddef> 19 #include <vector> 20 21 namespace clang { 22 namespace tooling { 23 24 static StringRef getDriverMode(const CommandLineArguments &Args) { 25 for (const auto &Arg : Args) { 26 StringRef ArgRef = Arg; 27 if (ArgRef.consume_front("--driver-mode=")) { 28 return ArgRef; 29 } 30 } 31 return StringRef(); 32 } 33 34 /// Add -fsyntax-only option and drop options that triggers output generation. 35 ArgumentsAdjuster getClangSyntaxOnlyAdjuster() { 36 return [](const CommandLineArguments &Args, StringRef /*unused*/) { 37 CommandLineArguments AdjustedArgs; 38 bool HasSyntaxOnly = false; 39 constexpr llvm::StringRef OutputCommands[] = { 40 // FIXME: Add other options that generate output. 41 "-save-temps", 42 "--save-temps", 43 }; 44 for (size_t i = 0, e = Args.size(); i < e; ++i) { 45 StringRef Arg = Args[i]; 46 // Skip output commands. 47 if (llvm::any_of(OutputCommands, [&Arg](llvm::StringRef OutputCommand) { 48 return Arg.startswith(OutputCommand); 49 })) 50 continue; 51 52 if (!Arg.startswith("-fcolor-diagnostics") && 53 !Arg.startswith("-fdiagnostics-color")) 54 AdjustedArgs.push_back(Args[i]); 55 // If we strip a color option, make sure we strip any preceeding `-Xclang` 56 // option as well. 57 // FIXME: This should be added to most argument adjusters! 58 else if (!AdjustedArgs.empty() && AdjustedArgs.back() == "-Xclang") 59 AdjustedArgs.pop_back(); 60 61 if (Arg == "-fsyntax-only") 62 HasSyntaxOnly = true; 63 } 64 if (!HasSyntaxOnly) 65 AdjustedArgs.push_back("-fsyntax-only"); 66 return AdjustedArgs; 67 }; 68 } 69 70 ArgumentsAdjuster getClangStripOutputAdjuster() { 71 return [](const CommandLineArguments &Args, StringRef /*unused*/) { 72 CommandLineArguments AdjustedArgs; 73 for (size_t i = 0, e = Args.size(); i < e; ++i) { 74 StringRef Arg = Args[i]; 75 if (!Arg.startswith("-o")) 76 AdjustedArgs.push_back(Args[i]); 77 78 if (Arg == "-o") { 79 // Output is specified as -o foo. Skip the next argument too. 80 ++i; 81 } 82 // Else, the output is specified as -ofoo. Just do nothing. 83 } 84 return AdjustedArgs; 85 }; 86 } 87 88 ArgumentsAdjuster getClangStripSerializeDiagnosticAdjuster() { 89 return [](const CommandLineArguments &Args, StringRef /*unused*/) { 90 CommandLineArguments AdjustedArgs; 91 for (size_t i = 0, e = Args.size(); i < e; ++i) { 92 StringRef Arg = Args[i]; 93 if (Arg == "--serialize-diagnostics") { 94 // Skip the diagnostic output argument. 95 ++i; 96 continue; 97 } 98 AdjustedArgs.push_back(Args[i]); 99 } 100 return AdjustedArgs; 101 }; 102 } 103 104 ArgumentsAdjuster getClangStripDependencyFileAdjuster() { 105 return [](const CommandLineArguments &Args, StringRef /*unused*/) { 106 auto UsingClDriver = (getDriverMode(Args) == "cl"); 107 108 CommandLineArguments AdjustedArgs; 109 for (size_t i = 0, e = Args.size(); i < e; ++i) { 110 StringRef Arg = Args[i]; 111 112 // These flags take an argument: -MX foo. Skip the next argument also. 113 if (!UsingClDriver && (Arg == "-MF" || Arg == "-MT" || Arg == "-MQ")) { 114 ++i; 115 continue; 116 } 117 // When not using the cl driver mode, dependency file generation options 118 // begin with -M. These include -MM, -MF, -MG, -MP, -MT, -MQ, -MD, and 119 // -MMD. 120 if (!UsingClDriver && Arg.startswith("-M")) 121 continue; 122 // Under MSVC's cl driver mode, dependency file generation is controlled 123 // using /showIncludes 124 if (Arg.startswith("/showIncludes") || Arg.startswith("-showIncludes")) 125 continue; 126 127 AdjustedArgs.push_back(Args[i]); 128 } 129 return AdjustedArgs; 130 }; 131 } 132 133 ArgumentsAdjuster getInsertArgumentAdjuster(const CommandLineArguments &Extra, 134 ArgumentInsertPosition Pos) { 135 return [Extra, Pos](const CommandLineArguments &Args, StringRef /*unused*/) { 136 CommandLineArguments Return(Args); 137 138 CommandLineArguments::iterator I; 139 if (Pos == ArgumentInsertPosition::END) { 140 I = Return.end(); 141 } else { 142 I = Return.begin(); 143 ++I; // To leave the program name in place 144 } 145 146 Return.insert(I, Extra.begin(), Extra.end()); 147 return Return; 148 }; 149 } 150 151 ArgumentsAdjuster getInsertArgumentAdjuster(const char *Extra, 152 ArgumentInsertPosition Pos) { 153 return getInsertArgumentAdjuster(CommandLineArguments(1, Extra), Pos); 154 } 155 156 ArgumentsAdjuster combineAdjusters(ArgumentsAdjuster First, 157 ArgumentsAdjuster Second) { 158 if (!First) 159 return Second; 160 if (!Second) 161 return First; 162 return [First, Second](const CommandLineArguments &Args, StringRef File) { 163 return Second(First(Args, File), File); 164 }; 165 } 166 167 ArgumentsAdjuster getStripPluginsAdjuster() { 168 return [](const CommandLineArguments &Args, StringRef /*unused*/) { 169 CommandLineArguments AdjustedArgs; 170 for (size_t I = 0, E = Args.size(); I != E; I++) { 171 // According to https://clang.llvm.org/docs/ClangPlugins.html 172 // plugin arguments are in the form: 173 // -Xclang {-load, -plugin, -plugin-arg-<plugin-name>, -add-plugin} 174 // -Xclang <arbitrary-argument> 175 if (I + 4 < E && Args[I] == "-Xclang" && 176 (Args[I + 1] == "-load" || Args[I + 1] == "-plugin" || 177 llvm::StringRef(Args[I + 1]).startswith("-plugin-arg-") || 178 Args[I + 1] == "-add-plugin") && 179 Args[I + 2] == "-Xclang") { 180 I += 3; 181 continue; 182 } 183 AdjustedArgs.push_back(Args[I]); 184 } 185 return AdjustedArgs; 186 }; 187 } 188 189 } // end namespace tooling 190 } // end namespace clang 191