1 //===-- cc1gen_reproducer_main.cpp - Clang reproducer generator  ----------===//
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 is the entry point to the clang -cc1gen-reproducer functionality, which
10 // generates reproducers for invocations for clang-based tools.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/Diagnostic.h"
15 #include "clang/Basic/LLVM.h"
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/Host.h"
22 #include "llvm/Support/TargetSelect.h"
23 #include "llvm/Support/VirtualFileSystem.h"
24 #include "llvm/Support/YAMLTraits.h"
25 #include "llvm/Support/raw_ostream.h"
26 #include <optional>
27 
28 using namespace clang;
29 
30 namespace {
31 
32 struct UnsavedFileHash {
33   std::string Name;
34   std::string MD5;
35 };
36 
37 struct ClangInvocationInfo {
38   std::string Toolchain;
39   std::string LibclangOperation;
40   std::string LibclangOptions;
41   std::vector<std::string> Arguments;
42   std::vector<std::string> InvocationArguments;
43   std::vector<UnsavedFileHash> UnsavedFileHashes;
44   bool Dump = false;
45 };
46 
47 } // end anonymous namespace
48 
49 LLVM_YAML_IS_SEQUENCE_VECTOR(UnsavedFileHash)
50 
51 namespace llvm {
52 namespace yaml {
53 
54 template <> struct MappingTraits<UnsavedFileHash> {
55   static void mapping(IO &IO, UnsavedFileHash &Info) {
56     IO.mapRequired("name", Info.Name);
57     IO.mapRequired("md5", Info.MD5);
58   }
59 };
60 
61 template <> struct MappingTraits<ClangInvocationInfo> {
62   static void mapping(IO &IO, ClangInvocationInfo &Info) {
63     IO.mapRequired("toolchain", Info.Toolchain);
64     IO.mapOptional("libclang.operation", Info.LibclangOperation);
65     IO.mapOptional("libclang.opts", Info.LibclangOptions);
66     IO.mapRequired("args", Info.Arguments);
67     IO.mapOptional("invocation-args", Info.InvocationArguments);
68     IO.mapOptional("unsaved_file_hashes", Info.UnsavedFileHashes);
69   }
70 };
71 
72 } // end namespace yaml
73 } // end namespace llvm
74 
75 static std::string generateReproducerMetaInfo(const ClangInvocationInfo &Info) {
76   std::string Result;
77   llvm::raw_string_ostream OS(Result);
78   OS << '{';
79   bool NeedComma = false;
80   auto EmitKey = [&](StringRef Key) {
81     if (NeedComma)
82       OS << ", ";
83     NeedComma = true;
84     OS << '"' << Key << "\": ";
85   };
86   auto EmitStringKey = [&](StringRef Key, StringRef Value) {
87     if (Value.empty())
88       return;
89     EmitKey(Key);
90     OS << '"' << Value << '"';
91   };
92   EmitStringKey("libclang.operation", Info.LibclangOperation);
93   EmitStringKey("libclang.opts", Info.LibclangOptions);
94   if (!Info.InvocationArguments.empty()) {
95     EmitKey("invocation-args");
96     OS << '[';
97     for (const auto &Arg : llvm::enumerate(Info.InvocationArguments)) {
98       if (Arg.index())
99         OS << ',';
100       OS << '"' << Arg.value() << '"';
101     }
102     OS << ']';
103   }
104   OS << '}';
105   // FIXME: Compare unsaved file hashes and report mismatch in the reproducer.
106   if (Info.Dump)
107     llvm::outs() << "REPRODUCER METAINFO: " << OS.str() << "\n";
108   return std::move(OS.str());
109 }
110 
111 /// Generates a reproducer for a set of arguments from a specific invocation.
112 static std::optional<driver::Driver::CompilationDiagnosticReport>
113 generateReproducerForInvocationArguments(ArrayRef<const char *> Argv,
114                                          const ClangInvocationInfo &Info) {
115   using namespace driver;
116   auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Argv[0]);
117 
118   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions;
119 
120   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
121   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new IgnoringDiagConsumer());
122   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
123   Driver TheDriver(Argv[0], llvm::sys::getDefaultTargetTriple(), Diags);
124   TheDriver.setTargetAndMode(TargetAndMode);
125 
126   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Argv));
127   if (C && !C->containsError()) {
128     for (const auto &J : C->getJobs()) {
129       if (const Command *Cmd = dyn_cast<Command>(&J)) {
130         Driver::CompilationDiagnosticReport Report;
131         TheDriver.generateCompilationDiagnostics(
132             *C, *Cmd, generateReproducerMetaInfo(Info), &Report);
133         return Report;
134       }
135     }
136   }
137 
138   return std::nullopt;
139 }
140 
141 std::string GetExecutablePath(const char *Argv0, bool CanonicalPrefixes);
142 
143 static void printReproducerInformation(
144     llvm::raw_ostream &OS, const ClangInvocationInfo &Info,
145     const driver::Driver::CompilationDiagnosticReport &Report) {
146   OS << "REPRODUCER:\n";
147   OS << "{\n";
148   OS << R"("files":[)";
149   for (const auto &File : llvm::enumerate(Report.TemporaryFiles)) {
150     if (File.index())
151       OS << ',';
152     OS << '"' << File.value() << '"';
153   }
154   OS << "]\n}\n";
155 }
156 
157 int cc1gen_reproducer_main(ArrayRef<const char *> Argv, const char *Argv0,
158                            void *MainAddr) {
159   if (Argv.size() < 1) {
160     llvm::errs() << "error: missing invocation file\n";
161     return 1;
162   }
163   // Parse the invocation descriptor.
164   StringRef Input = Argv[0];
165   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
166       llvm::MemoryBuffer::getFile(Input, /*IsText=*/true);
167   if (!Buffer) {
168     llvm::errs() << "error: failed to read " << Input << ": "
169                  << Buffer.getError().message() << "\n";
170     return 1;
171   }
172   llvm::yaml::Input YAML(Buffer.get()->getBuffer());
173   ClangInvocationInfo InvocationInfo;
174   YAML >> InvocationInfo;
175   if (Argv.size() > 1 && Argv[1] == StringRef("-v"))
176     InvocationInfo.Dump = true;
177 
178   // Create an invocation that will produce the reproducer.
179   std::vector<const char *> DriverArgs;
180   for (const auto &Arg : InvocationInfo.Arguments)
181     DriverArgs.push_back(Arg.c_str());
182   std::string Path = GetExecutablePath(Argv0, /*CanonicalPrefixes=*/true);
183   DriverArgs[0] = Path.c_str();
184   std::optional<driver::Driver::CompilationDiagnosticReport> Report =
185       generateReproducerForInvocationArguments(DriverArgs, InvocationInfo);
186 
187   // Emit the information about the reproduce files to stdout.
188   int Result = 1;
189   if (Report) {
190     printReproducerInformation(llvm::outs(), InvocationInfo, *Report);
191     Result = 0;
192   }
193 
194   // Remove the input file.
195   llvm::sys::fs::remove(Input);
196   return Result;
197 }
198