|
| 1 | +//===--- swift_cache_tool_main.cpp - Swift caching tool for inspection ----===// |
| 2 | +// |
| 3 | +// This source file is part of the Swift.org open source project |
| 4 | +// |
| 5 | +// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors |
| 6 | +// Licensed under Apache License v2.0 with Runtime Library Exception |
| 7 | +// |
| 8 | +// See https://swift.org/LICENSE.txt for license information |
| 9 | +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| 10 | +// |
| 11 | +//===----------------------------------------------------------------------===// |
| 12 | +// |
| 13 | +// Utility tool for inspecting and accessing swift cache. |
| 14 | +// |
| 15 | +//===----------------------------------------------------------------------===// |
| 16 | +// |
| 17 | +#include "swift/AST/DiagnosticsFrontend.h" |
| 18 | +#include "swift/Basic/LLVM.h" |
| 19 | +#include "swift/Basic/LLVMInitialize.h" |
| 20 | +#include "swift/Basic/Version.h" |
| 21 | +#include "swift/Frontend/CompileJobCacheKey.h" |
| 22 | +#include "swift/Frontend/Frontend.h" |
| 23 | +#include "swift/Frontend/PrintingDiagnosticConsumer.h" |
| 24 | +#include "swift/Option/Options.h" |
| 25 | +#include "swift/Parse/ParseVersion.h" |
| 26 | +#include "llvm/CAS/ActionCache.h" |
| 27 | +#include "llvm/CAS/BuiltinUnifiedCASDatabases.h" |
| 28 | +#include "llvm/CAS/ObjectStore.h" |
| 29 | +#include "llvm/Support/JSON.h" |
| 30 | +#include <memory> |
| 31 | + |
| 32 | +using namespace swift; |
| 33 | +using namespace llvm::opt; |
| 34 | +using namespace llvm::cas; |
| 35 | + |
| 36 | +namespace { |
| 37 | + |
| 38 | +enum class SwiftCacheToolAction { |
| 39 | + Invalid, |
| 40 | + PrintBaseKey, |
| 41 | + PrintOutputKeys |
| 42 | +}; |
| 43 | + |
| 44 | +class SwiftCacheToolInvocation { |
| 45 | +private: |
| 46 | + CompilerInstance Instance; |
| 47 | + CompilerInvocation Invocation; |
| 48 | + PrintingDiagnosticConsumer PDC; |
| 49 | + std::string MainExecutablePath; |
| 50 | + std::string CASPath; |
| 51 | + std::vector<std::string> FrontendArgs; |
| 52 | + SwiftCacheToolAction ActionKind = SwiftCacheToolAction::Invalid; |
| 53 | + |
| 54 | +public: |
| 55 | + SwiftCacheToolInvocation(const std::string &ExecPath) |
| 56 | + : MainExecutablePath(ExecPath) { |
| 57 | + Instance.addDiagnosticConsumer(&PDC); |
| 58 | + } |
| 59 | + |
| 60 | + int parseArgs(ArrayRef<const char *> Args) { |
| 61 | + using namespace options; |
| 62 | + auto &Diags = Instance.getDiags(); |
| 63 | + |
| 64 | + std::unique_ptr<llvm::opt::OptTable> Table = createSwiftOptTable(); |
| 65 | + unsigned MissingIndex; |
| 66 | + unsigned MissingCount; |
| 67 | + llvm::opt::InputArgList ParsedArgs = Table->ParseArgs( |
| 68 | + Args, MissingIndex, MissingCount, SwiftCacheToolOption); |
| 69 | + if (MissingCount) { |
| 70 | + Diags.diagnose(SourceLoc(), diag::error_missing_arg_value, |
| 71 | + ParsedArgs.getArgString(MissingIndex), MissingCount); |
| 72 | + return 1; |
| 73 | + } |
| 74 | + |
| 75 | + if (ParsedArgs.getLastArg(OPT_help)) { |
| 76 | + std::string ExecutableName = |
| 77 | + llvm::sys::path::stem(MainExecutablePath).str(); |
| 78 | + Table->printHelp(llvm::outs(), ExecutableName.c_str(), |
| 79 | + "Swift Cache Tool", options::SwiftCacheToolOption, 0, |
| 80 | + /*ShowAllAliases*/ false); |
| 81 | + return 0; |
| 82 | + } |
| 83 | + |
| 84 | + CASPath = |
| 85 | + ParsedArgs.getLastArgValue(OPT_cas_path, getDefaultOnDiskCASPath()); |
| 86 | + |
| 87 | + FrontendArgs = ParsedArgs.getAllArgValues(OPT__DASH_DASH); |
| 88 | + if (auto *A = ParsedArgs.getLastArg(OPT_cache_tool_action)) |
| 89 | + ActionKind = |
| 90 | + llvm::StringSwitch<SwiftCacheToolAction>(A->getValue()) |
| 91 | + .Case("print-base-key", SwiftCacheToolAction::PrintBaseKey) |
| 92 | + .Case("print-output-keys", SwiftCacheToolAction::PrintOutputKeys) |
| 93 | + .Default(SwiftCacheToolAction::Invalid); |
| 94 | + |
| 95 | + if (ActionKind == SwiftCacheToolAction::Invalid) { |
| 96 | + llvm::errs() << "Invalid option specified for -cache-tool-action: " |
| 97 | + << "use print-base-key|print-output-keys\n"; |
| 98 | + return 1; |
| 99 | + } |
| 100 | + |
| 101 | + return 0; |
| 102 | + } |
| 103 | + |
| 104 | + int run() { |
| 105 | + switch (ActionKind) { |
| 106 | + case SwiftCacheToolAction::PrintBaseKey: |
| 107 | + return printBaseKey(); |
| 108 | + case SwiftCacheToolAction::PrintOutputKeys: |
| 109 | + return printOutputKeys(); |
| 110 | + case SwiftCacheToolAction::Invalid: |
| 111 | + llvm::report_fatal_error("invalid action"); |
| 112 | + } |
| 113 | + } |
| 114 | + |
| 115 | +private: |
| 116 | + bool setupCompiler() { |
| 117 | + // Setup invocation. |
| 118 | + SmallString<128> workingDirectory; |
| 119 | + llvm::sys::fs::current_path(workingDirectory); |
| 120 | + |
| 121 | + // Parse arguments. |
| 122 | + if (FrontendArgs.empty()) { |
| 123 | + llvm::errs() << "missing swift-frontend command-line after --\n"; |
| 124 | + return true; |
| 125 | + } |
| 126 | + // drop swift-frontend executable path from command-line. |
| 127 | + if (StringRef(FrontendArgs[0]).endswith("swift-frontend")) |
| 128 | + FrontendArgs.erase(FrontendArgs.begin()); |
| 129 | + |
| 130 | + SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> |
| 131 | + configurationFileBuffers; |
| 132 | + std::vector<const char*> Args; |
| 133 | + for (auto &A: FrontendArgs) |
| 134 | + Args.emplace_back(A.c_str()); |
| 135 | + |
| 136 | + // Make sure CASPath is the same between invocation and cache-tool by |
| 137 | + // appending the cas-path since the option doesn't affect cache key. |
| 138 | + Args.emplace_back("-cas-path"); |
| 139 | + Args.emplace_back(CASPath.c_str()); |
| 140 | + |
| 141 | + if (Invocation.parseArgs(Args, Instance.getDiags(), |
| 142 | + &configurationFileBuffers, workingDirectory, |
| 143 | + MainExecutablePath)) |
| 144 | + return true; |
| 145 | + |
| 146 | + if (!Invocation.getFrontendOptions().EnableCAS) { |
| 147 | + llvm::errs() << "Requested command-line arguments do not enable CAS\n"; |
| 148 | + return true; |
| 149 | + } |
| 150 | + |
| 151 | + // Setup instance. |
| 152 | + std::string InstanceSetupError; |
| 153 | + if (Instance.setup(Invocation, InstanceSetupError, Args)) { |
| 154 | + llvm::errs() << "swift-frontend invocation setup error: " |
| 155 | + << InstanceSetupError << "\n"; |
| 156 | + return true; |
| 157 | + } |
| 158 | + |
| 159 | + return false; |
| 160 | + } |
| 161 | + |
| 162 | + Optional<ObjectRef> getBaseKey() { |
| 163 | + auto BaseKey = Instance.getCompilerBaseKey(); |
| 164 | + if (!BaseKey) { |
| 165 | + Instance.getDiags().diagnose(SourceLoc(), diag::error_cas, |
| 166 | + "Base Key doesn't exist"); |
| 167 | + return None; |
| 168 | + } |
| 169 | + |
| 170 | + return *BaseKey; |
| 171 | + } |
| 172 | + |
| 173 | + int printBaseKey() { |
| 174 | + if (setupCompiler()) |
| 175 | + return 1; |
| 176 | + |
| 177 | + auto &CAS = Instance.getObjectStore(); |
| 178 | + auto BaseKey = getBaseKey(); |
| 179 | + if (!BaseKey) |
| 180 | + return 1; |
| 181 | + |
| 182 | + if (ActionKind == SwiftCacheToolAction::PrintBaseKey) |
| 183 | + llvm::outs() << CAS.getID(*BaseKey).toString() << "\n"; |
| 184 | + |
| 185 | + return 0; |
| 186 | + } |
| 187 | + |
| 188 | + int printOutputKeys(); |
| 189 | +}; |
| 190 | + |
| 191 | +} // end anonymous namespace |
| 192 | + |
| 193 | +int SwiftCacheToolInvocation::printOutputKeys() { |
| 194 | + if (setupCompiler()) |
| 195 | + return 1; |
| 196 | + |
| 197 | + auto &CAS = Instance.getObjectStore(); |
| 198 | + auto BaseKey = getBaseKey(); |
| 199 | + if (!BaseKey) |
| 200 | + return 1; |
| 201 | + |
| 202 | + struct OutputEntry { |
| 203 | + std::string InputPath; |
| 204 | + std::string OutputPath; |
| 205 | + std::string OutputKind; |
| 206 | + std::string CacheKey; |
| 207 | + }; |
| 208 | + std::vector<OutputEntry> OutputKeys; |
| 209 | + bool hasError = false; |
| 210 | + auto addOutputKey = [&](StringRef InputPath, file_types::ID OutputKind, |
| 211 | + StringRef OutputPath) { |
| 212 | + auto OutputKey = |
| 213 | + createCompileJobCacheKeyForOutput(CAS, *BaseKey, InputPath, OutputKind); |
| 214 | + if (!OutputKey) { |
| 215 | + llvm::errs() << "cannot create cache key for " << OutputPath << ": " |
| 216 | + << toString(OutputKey.takeError()) << "\n"; |
| 217 | + hasError = true; |
| 218 | + } |
| 219 | + OutputKeys.emplace_back( |
| 220 | + OutputEntry{InputPath.str(), OutputPath.str(), |
| 221 | + file_types::getTypeName(OutputKind).str(), |
| 222 | + CAS.getID(*OutputKey).toString()}); |
| 223 | + }; |
| 224 | + auto addFromInputFile = [&](const InputFile &Input) { |
| 225 | + auto InputPath = Input.getFileName(); |
| 226 | + if (!Input.outputFilename().empty()) |
| 227 | + addOutputKey( |
| 228 | + InputPath, |
| 229 | + Invocation.getFrontendOptions().InputsAndOutputs.getOutputType(), |
| 230 | + Input.outputFilename()); |
| 231 | + Input.getPrimarySpecificPaths() |
| 232 | + .SupplementaryOutputs.forEachSetOutputAndType( |
| 233 | + [&](const std::string &File, file_types::ID ID) { |
| 234 | + // Dont print serialized diagnostics. |
| 235 | + if (ID == file_types::ID::TY_SerializedDiagnostics) |
| 236 | + return; |
| 237 | + |
| 238 | + addOutputKey(InputPath, ID, File); |
| 239 | + }); |
| 240 | + }; |
| 241 | + llvm::for_each( |
| 242 | + Invocation.getFrontendOptions().InputsAndOutputs.getAllInputs(), |
| 243 | + addFromInputFile); |
| 244 | + |
| 245 | + if (hasError) |
| 246 | + return 1; |
| 247 | + |
| 248 | + llvm::json::OStream Out(llvm::outs(), /*IndentSize=*/4); |
| 249 | + Out.array([&] { |
| 250 | + for (const auto &E : OutputKeys) { |
| 251 | + Out.object([&] { |
| 252 | + Out.attribute("OutputPath", E.OutputPath); |
| 253 | + Out.attribute("OutputKind", E.OutputKind); |
| 254 | + Out.attribute("Input", E.InputPath); |
| 255 | + Out.attribute("CacheKey", E.CacheKey); |
| 256 | + }); |
| 257 | + } |
| 258 | + }); |
| 259 | + |
| 260 | + return 0; |
| 261 | +} |
| 262 | + |
| 263 | +int swift_cache_tool_main(ArrayRef<const char *> Args, const char *Argv0, |
| 264 | + void *MainAddr) { |
| 265 | + INITIALIZE_LLVM(); |
| 266 | + |
| 267 | + SwiftCacheToolInvocation Invocation( |
| 268 | + llvm::sys::fs::getMainExecutable(Argv0, MainAddr)); |
| 269 | + |
| 270 | + if (Invocation.parseArgs(Args) != 0) |
| 271 | + return EXIT_FAILURE; |
| 272 | + |
| 273 | + if (Invocation.run() != 0) |
| 274 | + return EXIT_FAILURE; |
| 275 | + |
| 276 | + return EXIT_SUCCESS; |
| 277 | +} |
0 commit comments