/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/tools/arcmt-test/arcmt-test.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- arcmt-test.cpp - ARC Migration Tool testbed -----------------------===// |
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 | | #include "clang/ARCMigrate/ARCMT.h" |
10 | | #include "clang/AST/ASTContext.h" |
11 | | #include "clang/Frontend/PCHContainerOperations.h" |
12 | | #include "clang/Frontend/TextDiagnosticPrinter.h" |
13 | | #include "clang/Frontend/Utils.h" |
14 | | #include "clang/Frontend/VerifyDiagnosticConsumer.h" |
15 | | #include "clang/Lex/Preprocessor.h" |
16 | | #include "clang/Lex/PreprocessorOptions.h" |
17 | | #include "llvm/Support/FileSystem.h" |
18 | | #include "llvm/Support/MemoryBuffer.h" |
19 | | #include "llvm/Support/Path.h" |
20 | | #include "llvm/Support/Signals.h" |
21 | | #include <system_error> |
22 | | |
23 | | using namespace clang; |
24 | | using namespace arcmt; |
25 | | |
26 | | static llvm::cl::opt<bool> |
27 | | CheckOnly("check-only", |
28 | | llvm::cl::desc("Just check for issues that need to be handled manually")); |
29 | | |
30 | | //static llvm::cl::opt<bool> |
31 | | //TestResultForARC("test-result", |
32 | | //llvm::cl::desc("Test the result of transformations by parsing it in ARC mode")); |
33 | | |
34 | | static llvm::cl::opt<bool> |
35 | | OutputTransformations("output-transformations", |
36 | | llvm::cl::desc("Print the source transformations")); |
37 | | |
38 | | static llvm::cl::opt<bool> |
39 | | VerifyDiags("verify",llvm::cl::desc("Verify emitted diagnostics and warnings")); |
40 | | |
41 | | static llvm::cl::opt<bool> |
42 | | VerboseOpt("v", llvm::cl::desc("Enable verbose output")); |
43 | | |
44 | | static llvm::cl::opt<bool> |
45 | | VerifyTransformedFiles("verify-transformed-files", |
46 | | llvm::cl::desc("Read pairs of file mappings (typically the output of " |
47 | | "c-arcmt-test) and compare their contents with the filenames " |
48 | | "provided in command-line")); |
49 | | |
50 | | static llvm::cl::opt<std::string> |
51 | | RemappingsFile("remappings-file", |
52 | | llvm::cl::desc("Pairs of file mappings (typically the output of " |
53 | | "c-arcmt-test)")); |
54 | | |
55 | | static llvm::cl::list<std::string> |
56 | | ResultFiles(llvm::cl::Positional, llvm::cl::desc("<filename>...")); |
57 | | |
58 | | static llvm::cl::extrahelp extraHelp( |
59 | | "\nusage with compiler args: arcmt-test [options] --args [compiler flags]\n"); |
60 | | |
61 | | // This function isn't referenced outside its translation unit, but it |
62 | | // can't use the "static" keyword because its address is used for |
63 | | // GetMainExecutable (since some platforms don't support taking the |
64 | | // address of main, and some platforms can't implement GetMainExecutable |
65 | | // without being given the address of a function in the main executable). |
66 | 24 | std::string GetExecutablePath(const char *Argv0) { |
67 | | // This just needs to be some symbol in the binary; C++ doesn't |
68 | | // allow taking the address of ::main however. |
69 | 24 | void *MainAddr = (void*) (intptr_t) GetExecutablePath; |
70 | 24 | return llvm::sys::fs::getMainExecutable(Argv0, MainAddr); |
71 | 24 | } |
72 | | |
73 | | static void printSourceLocation(SourceLocation loc, ASTContext &Ctx, |
74 | | raw_ostream &OS); |
75 | | static void printSourceRange(CharSourceRange range, ASTContext &Ctx, |
76 | | raw_ostream &OS); |
77 | | |
78 | | namespace { |
79 | | |
80 | | class PrintTransforms : public MigrationProcess::RewriteListener { |
81 | | ASTContext *Ctx; |
82 | | raw_ostream &OS; |
83 | | |
84 | | public: |
85 | | PrintTransforms(raw_ostream &OS) |
86 | 0 | : Ctx(nullptr), OS(OS) {} |
87 | | |
88 | 0 | void start(ASTContext &ctx) override { Ctx = &ctx; } |
89 | 0 | void finish() override { Ctx = nullptr; } |
90 | | |
91 | 0 | void insert(SourceLocation loc, StringRef text) override { |
92 | 0 | assert(Ctx); |
93 | 0 | OS << "Insert: "; |
94 | 0 | printSourceLocation(loc, *Ctx, OS); |
95 | 0 | OS << " \"" << text << "\"\n"; |
96 | 0 | } |
97 | | |
98 | 0 | void remove(CharSourceRange range) override { |
99 | 0 | assert(Ctx); |
100 | 0 | OS << "Remove: "; |
101 | 0 | printSourceRange(range, *Ctx, OS); |
102 | 0 | OS << '\n'; |
103 | 0 | } |
104 | | }; |
105 | | |
106 | | } // anonymous namespace |
107 | | |
108 | | static bool checkForMigration(StringRef resourcesPath, |
109 | 26 | ArrayRef<const char *> Args) { |
110 | 26 | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); |
111 | 26 | DiagnosticConsumer *DiagClient = |
112 | 26 | new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); |
113 | 26 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
114 | 26 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
115 | 26 | new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient)); |
116 | | // Chain in -verify checker, if requested. |
117 | 26 | VerifyDiagnosticConsumer *verifyDiag = nullptr; |
118 | 26 | if (VerifyDiags) { |
119 | 0 | verifyDiag = new VerifyDiagnosticConsumer(*Diags); |
120 | 0 | Diags->setClient(verifyDiag); |
121 | 0 | } |
122 | | |
123 | 26 | CompilerInvocation CI; |
124 | 26 | if (!CompilerInvocation::CreateFromArgs(CI, Args, *Diags)) |
125 | 0 | return true; |
126 | | |
127 | 26 | if (CI.getFrontendOpts().Inputs.empty()) { |
128 | 0 | llvm::errs() << "error: no input files\n"; |
129 | 0 | return true; |
130 | 0 | } |
131 | | |
132 | 26 | if (!CI.getLangOpts()->ObjC) |
133 | 0 | return false; |
134 | | |
135 | 26 | arcmt::checkForManualIssues(CI, CI.getFrontendOpts().Inputs[0], |
136 | 26 | std::make_shared<PCHContainerOperations>(), |
137 | 26 | Diags->getClient()); |
138 | 26 | return Diags->getClient()->getNumErrors() > 0; |
139 | 26 | } |
140 | | |
141 | 25 | static void printResult(FileRemapper &remapper, raw_ostream &OS) { |
142 | 25 | remapper.forEachMapping([](StringRef, StringRef) {}0 , |
143 | 25 | [&](StringRef, const llvm::MemoryBufferRef &Buffer) { |
144 | 25 | OS << Buffer.getBuffer(); |
145 | 25 | }); |
146 | 25 | } |
147 | | |
148 | | static bool performTransformations(StringRef resourcesPath, |
149 | 26 | ArrayRef<const char *> Args) { |
150 | | // Check first. |
151 | 26 | if (checkForMigration(resourcesPath, Args)) |
152 | 1 | return true; |
153 | | |
154 | 25 | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); |
155 | 25 | DiagnosticConsumer *DiagClient = |
156 | 25 | new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); |
157 | 25 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
158 | 25 | IntrusiveRefCntPtr<DiagnosticsEngine> TopDiags( |
159 | 25 | new DiagnosticsEngine(DiagID, &*DiagOpts, &*DiagClient)); |
160 | | |
161 | 25 | CompilerInvocation origCI; |
162 | 25 | if (!CompilerInvocation::CreateFromArgs(origCI, Args, *TopDiags)) |
163 | 0 | return true; |
164 | | |
165 | 25 | if (origCI.getFrontendOpts().Inputs.empty()) { |
166 | 0 | llvm::errs() << "error: no input files\n"; |
167 | 0 | return true; |
168 | 0 | } |
169 | | |
170 | 25 | if (!origCI.getLangOpts()->ObjC) |
171 | 0 | return false; |
172 | | |
173 | 25 | MigrationProcess migration(origCI, std::make_shared<PCHContainerOperations>(), |
174 | 25 | DiagClient); |
175 | | |
176 | 25 | std::vector<TransformFn> |
177 | 25 | transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(), |
178 | 25 | origCI.getMigratorOpts().NoFinalizeRemoval); |
179 | 25 | assert(!transforms.empty()); |
180 | | |
181 | 0 | std::unique_ptr<PrintTransforms> transformPrinter; |
182 | 25 | if (OutputTransformations) |
183 | 0 | transformPrinter.reset(new PrintTransforms(llvm::outs())); |
184 | | |
185 | 77 | for (unsigned i=0, e = transforms.size(); i != e; ++i52 ) { |
186 | 52 | bool err = migration.applyTransform(transforms[i], transformPrinter.get()); |
187 | 52 | if (err) return true0 ; |
188 | | |
189 | 52 | if (VerboseOpt) { |
190 | 0 | if (i == e-1) |
191 | 0 | llvm::errs() << "\n##### FINAL RESULT #####\n"; |
192 | 0 | else |
193 | 0 | llvm::errs() << "\n##### OUTPUT AFTER "<< i+1 <<". TRANSFORMATION #####\n"; |
194 | 0 | printResult(migration.getRemapper(), llvm::errs()); |
195 | 0 | llvm::errs() << "\n##########################\n\n"; |
196 | 0 | } |
197 | 52 | } |
198 | | |
199 | 25 | if (!OutputTransformations) |
200 | 25 | printResult(migration.getRemapper(), llvm::outs()); |
201 | | |
202 | | // FIXME: TestResultForARC |
203 | | |
204 | 25 | return false; |
205 | 25 | } |
206 | | |
207 | 39 | static bool filesCompareEqual(StringRef fname1, StringRef fname2) { |
208 | 39 | using namespace llvm; |
209 | | |
210 | 39 | ErrorOr<std::unique_ptr<MemoryBuffer>> file1 = |
211 | 39 | MemoryBuffer::getFile(fname1, /*IsText=*/true); |
212 | 39 | if (!file1) |
213 | 0 | return false; |
214 | | |
215 | 39 | ErrorOr<std::unique_ptr<MemoryBuffer>> file2 = |
216 | 39 | MemoryBuffer::getFile(fname2, /*IsText=*/true); |
217 | 39 | if (!file2) |
218 | 0 | return false; |
219 | | |
220 | 39 | return file1.get()->getBuffer() == file2.get()->getBuffer(); |
221 | 39 | } |
222 | | |
223 | 30 | static bool verifyTransformedFiles(ArrayRef<std::string> resultFiles) { |
224 | 30 | using namespace llvm; |
225 | | |
226 | 30 | assert(!resultFiles.empty()); |
227 | | |
228 | 0 | std::map<StringRef, StringRef> resultMap; |
229 | | |
230 | 30 | for (ArrayRef<std::string>::iterator |
231 | 69 | I = resultFiles.begin(), E = resultFiles.end(); I != E; ++I39 ) { |
232 | 39 | StringRef fname(*I); |
233 | 39 | if (!fname.endswith(".result")) { |
234 | 0 | errs() << "error: filename '" << fname |
235 | 0 | << "' does not have '.result' extension\n"; |
236 | 0 | return true; |
237 | 0 | } |
238 | 39 | resultMap[sys::path::stem(fname)] = fname; |
239 | 39 | } |
240 | | |
241 | 30 | ErrorOr<std::unique_ptr<MemoryBuffer>> inputBuf = std::error_code(); |
242 | 30 | if (RemappingsFile.empty()) |
243 | 30 | inputBuf = MemoryBuffer::getSTDIN(); |
244 | 0 | else |
245 | 0 | inputBuf = MemoryBuffer::getFile(RemappingsFile, /*IsText=*/true); |
246 | 30 | if (!inputBuf) { |
247 | 0 | errs() << "error: could not read remappings input\n"; |
248 | 0 | return true; |
249 | 0 | } |
250 | | |
251 | 30 | SmallVector<StringRef, 8> strs; |
252 | 30 | inputBuf.get()->getBuffer().split(strs, "\n", /*MaxSplit=*/-1, |
253 | 30 | /*KeepEmpty=*/false); |
254 | | |
255 | 30 | if (strs.empty()) { |
256 | 0 | errs() << "error: no files to verify from stdin\n"; |
257 | 0 | return true; |
258 | 0 | } |
259 | 30 | if (strs.size() % 2 != 0) { |
260 | 0 | errs() << "error: files to verify are not original/result pairs\n"; |
261 | 0 | return true; |
262 | 0 | } |
263 | | |
264 | 69 | for (unsigned i = 0, e = strs.size(); 30 i != e; i += 239 ) { |
265 | 39 | StringRef inputOrigFname = strs[i]; |
266 | 39 | StringRef inputResultFname = strs[i+1]; |
267 | | |
268 | 39 | std::map<StringRef, StringRef>::iterator It; |
269 | 39 | It = resultMap.find(sys::path::filename(inputOrigFname)); |
270 | 39 | if (It == resultMap.end()) { |
271 | 0 | errs() << "error: '" << inputOrigFname << "' is not in the list of " |
272 | 0 | << "transformed files to verify\n"; |
273 | 0 | return true; |
274 | 0 | } |
275 | | |
276 | 39 | if (!sys::fs::exists(It->second)) { |
277 | 0 | errs() << "error: '" << It->second << "' does not exist\n"; |
278 | 0 | return true; |
279 | 0 | } |
280 | 39 | if (!sys::fs::exists(inputResultFname)) { |
281 | 0 | errs() << "error: '" << inputResultFname << "' does not exist\n"; |
282 | 0 | return true; |
283 | 0 | } |
284 | | |
285 | 39 | if (!filesCompareEqual(It->second, inputResultFname)) { |
286 | 0 | errs() << "error: '" << It->second << "' is different than " |
287 | 0 | << "'" << inputResultFname << "'\n"; |
288 | 0 | return true; |
289 | 0 | } |
290 | | |
291 | 39 | resultMap.erase(It); |
292 | 39 | } |
293 | | |
294 | 30 | if (!resultMap.empty()) { |
295 | 0 | for (std::map<StringRef, StringRef>::iterator |
296 | 0 | I = resultMap.begin(), E = resultMap.end(); I != E; ++I) |
297 | 0 | errs() << "error: '" << I->second << "' was not verified!\n"; |
298 | 0 | return true; |
299 | 0 | } |
300 | | |
301 | 30 | return false; |
302 | 30 | } |
303 | | |
304 | | //===----------------------------------------------------------------------===// |
305 | | // Misc. functions. |
306 | | //===----------------------------------------------------------------------===// |
307 | | |
308 | | static void printSourceLocation(SourceLocation loc, ASTContext &Ctx, |
309 | 0 | raw_ostream &OS) { |
310 | 0 | SourceManager &SM = Ctx.getSourceManager(); |
311 | 0 | PresumedLoc PL = SM.getPresumedLoc(loc); |
312 | |
|
313 | 0 | OS << llvm::sys::path::filename(PL.getFilename()); |
314 | 0 | OS << ":" << PL.getLine() << ":" |
315 | 0 | << PL.getColumn(); |
316 | 0 | } |
317 | | |
318 | | static void printSourceRange(CharSourceRange range, ASTContext &Ctx, |
319 | 0 | raw_ostream &OS) { |
320 | 0 | SourceManager &SM = Ctx.getSourceManager(); |
321 | 0 | const LangOptions &langOpts = Ctx.getLangOpts(); |
322 | |
|
323 | 0 | PresumedLoc PL = SM.getPresumedLoc(range.getBegin()); |
324 | |
|
325 | 0 | OS << llvm::sys::path::filename(PL.getFilename()); |
326 | 0 | OS << " [" << PL.getLine() << ":" |
327 | 0 | << PL.getColumn(); |
328 | 0 | OS << " - "; |
329 | |
|
330 | 0 | SourceLocation end = range.getEnd(); |
331 | 0 | PL = SM.getPresumedLoc(end); |
332 | |
|
333 | 0 | unsigned endCol = PL.getColumn() - 1; |
334 | 0 | if (!range.isTokenRange()) |
335 | 0 | endCol += Lexer::MeasureTokenLength(end, SM, langOpts); |
336 | 0 | OS << PL.getLine() << ":" << endCol << "]"; |
337 | 0 | } |
338 | | |
339 | | //===----------------------------------------------------------------------===// |
340 | | // Command line processing. |
341 | | //===----------------------------------------------------------------------===// |
342 | | |
343 | 56 | int main(int argc, const char **argv) { |
344 | 56 | void *MainAddr = (void*) (intptr_t) GetExecutablePath; |
345 | 56 | llvm::sys::PrintStackTraceOnErrorSignal(argv[0]); |
346 | | |
347 | 56 | std::string |
348 | 56 | resourcesPath = CompilerInvocation::GetResourcesPath(argv[0], MainAddr); |
349 | | |
350 | 56 | int optargc = 0; |
351 | 181 | for (; optargc != argc; ++optargc125 ) { |
352 | 151 | if (StringRef(argv[optargc]) == "--args") |
353 | 26 | break; |
354 | 151 | } |
355 | 56 | llvm::cl::ParseCommandLineOptions(optargc, argv, "arcmt-test"); |
356 | | |
357 | 56 | if (VerifyTransformedFiles) { |
358 | 30 | if (ResultFiles.empty()) { |
359 | 0 | llvm::cl::PrintHelpMessage(); |
360 | 0 | return 1; |
361 | 0 | } |
362 | 30 | return verifyTransformedFiles(ResultFiles); |
363 | 30 | } |
364 | | |
365 | 26 | if (optargc == argc) { |
366 | 0 | llvm::cl::PrintHelpMessage(); |
367 | 0 | return 1; |
368 | 0 | } |
369 | | |
370 | 26 | ArrayRef<const char*> Args(argv+optargc+1, argc-optargc-1); |
371 | | |
372 | 26 | if (CheckOnly) |
373 | 0 | return checkForMigration(resourcesPath, Args); |
374 | | |
375 | 26 | return performTransformations(resourcesPath, Args); |
376 | 26 | } |