Bug Summary

File:llvm/utils/FileCheck/FileCheck.cpp
Warning:line 633, column 18
Value stored to 'LineOS' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name FileCheck.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I utils/FileCheck -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/utils/FileCheck -I include -I /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-01-19-134126-35450-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220119111520+da61cb019eb2/llvm/utils/FileCheck/FileCheck.cpp
1//===- FileCheck.cpp - Check that File's Contents match what is expected --===//
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// FileCheck does a line-by line check of a file that validates whether it
10// contains the expected content. This is useful for regression tests etc.
11//
12// This program exits with an exit status of 2 on error, exit status of 0 if
13// the file matched the expected contents, and exit status of 1 if it did not
14// contain the expected contents.
15//
16//===----------------------------------------------------------------------===//
17
18#include "llvm/FileCheck/FileCheck.h"
19#include "llvm/Support/CommandLine.h"
20#include "llvm/Support/InitLLVM.h"
21#include "llvm/Support/Process.h"
22#include "llvm/Support/WithColor.h"
23#include "llvm/Support/raw_ostream.h"
24#include <cmath>
25#include <map>
26using namespace llvm;
27
28static cl::extrahelp FileCheckOptsEnv(
29 "\nOptions are parsed from the environment variable FILECHECK_OPTS and\n"
30 "from the command line.\n");
31
32static cl::opt<std::string>
33 CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Optional);
34
35static cl::opt<std::string>
36 InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),
37 cl::init("-"), cl::value_desc("filename"));
38
39static cl::list<std::string> CheckPrefixes(
40 "check-prefix",
41 cl::desc("Prefix to use from check file (defaults to 'CHECK')"));
42static cl::alias CheckPrefixesAlias(
43 "check-prefixes", cl::aliasopt(CheckPrefixes), cl::CommaSeparated,
44 cl::NotHidden,
45 cl::desc(
46 "Alias for -check-prefix permitting multiple comma separated values"));
47
48static cl::list<std::string> CommentPrefixes(
49 "comment-prefixes", cl::CommaSeparated, cl::Hidden,
50 cl::desc("Comma-separated list of comment prefixes to use from check file\n"
51 "(defaults to 'COM,RUN'). Please avoid using this feature in\n"
52 "LLVM's LIT-based test suites, which should be easier to\n"
53 "maintain if they all follow a consistent comment style. This\n"
54 "feature is meant for non-LIT test suites using FileCheck."));
55
56static cl::opt<bool> NoCanonicalizeWhiteSpace(
57 "strict-whitespace",
58 cl::desc("Do not treat all horizontal whitespace as equivalent"));
59
60static cl::opt<bool> IgnoreCase(
61 "ignore-case",
62 cl::desc("Use case-insensitive matching"));
63
64static cl::list<std::string> ImplicitCheckNot(
65 "implicit-check-not",
66 cl::desc("Add an implicit negative check with this pattern to every\n"
67 "positive check. This can be used to ensure that no instances of\n"
68 "this pattern occur which are not matched by a positive pattern"),
69 cl::value_desc("pattern"));
70
71static cl::list<std::string>
72 GlobalDefines("D", cl::AlwaysPrefix,
73 cl::desc("Define a variable to be used in capture patterns."),
74 cl::value_desc("VAR=VALUE"));
75
76static cl::opt<bool> AllowEmptyInput(
77 "allow-empty", cl::init(false),
78 cl::desc("Allow the input file to be empty. This is useful when making\n"
79 "checks that some error message does not occur, for example."));
80
81static cl::opt<bool> AllowUnusedPrefixes(
82 "allow-unused-prefixes", cl::init(false), cl::ZeroOrMore,
83 cl::desc("Allow prefixes to be specified but not appear in the test."));
84
85static cl::opt<bool> MatchFullLines(
86 "match-full-lines", cl::init(false),
87 cl::desc("Require all positive matches to cover an entire input line.\n"
88 "Allows leading and trailing whitespace if --strict-whitespace\n"
89 "is not also passed."));
90
91static cl::opt<bool> EnableVarScope(
92 "enable-var-scope", cl::init(false),
93 cl::desc("Enables scope for regex variables. Variables with names that\n"
94 "do not start with '$' will be reset at the beginning of\n"
95 "each CHECK-LABEL block."));
96
97static cl::opt<bool> AllowDeprecatedDagOverlap(
98 "allow-deprecated-dag-overlap", cl::init(false),
99 cl::desc("Enable overlapping among matches in a group of consecutive\n"
100 "CHECK-DAG directives. This option is deprecated and is only\n"
101 "provided for convenience as old tests are migrated to the new\n"
102 "non-overlapping CHECK-DAG implementation.\n"));
103
104static cl::opt<bool> Verbose(
105 "v", cl::init(false), cl::ZeroOrMore,
106 cl::desc("Print directive pattern matches, or add them to the input dump\n"
107 "if enabled.\n"));
108
109static cl::opt<bool> VerboseVerbose(
110 "vv", cl::init(false), cl::ZeroOrMore,
111 cl::desc("Print information helpful in diagnosing internal FileCheck\n"
112 "issues, or add it to the input dump if enabled. Implies\n"
113 "-v.\n"));
114
115// The order of DumpInputValue members affects their precedence, as documented
116// for -dump-input below.
117enum DumpInputValue {
118 DumpInputNever,
119 DumpInputFail,
120 DumpInputAlways,
121 DumpInputHelp
122};
123
124static cl::list<DumpInputValue> DumpInputs(
125 "dump-input",
126 cl::desc("Dump input to stderr, adding annotations representing\n"
127 "currently enabled diagnostics. When there are multiple\n"
128 "occurrences of this option, the <value> that appears earliest\n"
129 "in the list below has precedence. The default is 'fail'.\n"),
130 cl::value_desc("mode"),
131 cl::values(clEnumValN(DumpInputHelp, "help", "Explain input dump and quit")llvm::cl::OptionEnumValue { "help", int(DumpInputHelp), "Explain input dump and quit"
}
,
132 clEnumValN(DumpInputAlways, "always", "Always dump input")llvm::cl::OptionEnumValue { "always", int(DumpInputAlways), "Always dump input"
}
,
133 clEnumValN(DumpInputFail, "fail", "Dump input on failure")llvm::cl::OptionEnumValue { "fail", int(DumpInputFail), "Dump input on failure"
}
,
134 clEnumValN(DumpInputNever, "never", "Never dump input")llvm::cl::OptionEnumValue { "never", int(DumpInputNever), "Never dump input"
}
));
135
136// The order of DumpInputFilterValue members affects their precedence, as
137// documented for -dump-input-filter below.
138enum DumpInputFilterValue {
139 DumpInputFilterError,
140 DumpInputFilterAnnotation,
141 DumpInputFilterAnnotationFull,
142 DumpInputFilterAll
143};
144
145static cl::list<DumpInputFilterValue> DumpInputFilters(
146 "dump-input-filter",
147 cl::desc("In the dump requested by -dump-input, print only input lines of\n"
148 "kind <value> plus any context specified by -dump-input-context.\n"
149 "When there are multiple occurrences of this option, the <value>\n"
150 "that appears earliest in the list below has precedence. The\n"
151 "default is 'error' when -dump-input=fail, and it's 'all' when\n"
152 "-dump-input=always.\n"),
153 cl::values(clEnumValN(DumpInputFilterAll, "all", "All input lines")llvm::cl::OptionEnumValue { "all", int(DumpInputFilterAll), "All input lines"
}
,
154 clEnumValN(DumpInputFilterAnnotationFull, "annotation-full",llvm::cl::OptionEnumValue { "annotation-full", int(DumpInputFilterAnnotationFull
), "Input lines with annotations" }
155 "Input lines with annotations")llvm::cl::OptionEnumValue { "annotation-full", int(DumpInputFilterAnnotationFull
), "Input lines with annotations" }
,
156 clEnumValN(DumpInputFilterAnnotation, "annotation",llvm::cl::OptionEnumValue { "annotation", int(DumpInputFilterAnnotation
), "Input lines with starting points of annotations" }
157 "Input lines with starting points of annotations")llvm::cl::OptionEnumValue { "annotation", int(DumpInputFilterAnnotation
), "Input lines with starting points of annotations" }
,
158 clEnumValN(DumpInputFilterError, "error",llvm::cl::OptionEnumValue { "error", int(DumpInputFilterError
), "Input lines with starting points of error " "annotations"
}
159 "Input lines with starting points of error "llvm::cl::OptionEnumValue { "error", int(DumpInputFilterError
), "Input lines with starting points of error " "annotations"
}
160 "annotations")llvm::cl::OptionEnumValue { "error", int(DumpInputFilterError
), "Input lines with starting points of error " "annotations"
}
));
161
162static cl::list<unsigned> DumpInputContexts(
163 "dump-input-context", cl::value_desc("N"),
164 cl::desc("In the dump requested by -dump-input, print <N> input lines\n"
165 "before and <N> input lines after any lines specified by\n"
166 "-dump-input-filter. When there are multiple occurrences of\n"
167 "this option, the largest specified <N> has precedence. The\n"
168 "default is 5.\n"));
169
170typedef cl::list<std::string>::const_iterator prefix_iterator;
171
172
173
174
175
176
177
178static void DumpCommandLine(int argc, char **argv) {
179 errs() << "FileCheck command line: ";
180 for (int I = 0; I < argc; I++)
181 errs() << " " << argv[I];
182 errs() << "\n";
183}
184
185struct MarkerStyle {
186 /// The starting char (before tildes) for marking the line.
187 char Lead;
188 /// What color to use for this annotation.
189 raw_ostream::Colors Color;
190 /// A note to follow the marker, or empty string if none.
191 std::string Note;
192 /// Does this marker indicate inclusion by -dump-input-filter=error?
193 bool FiltersAsError;
194 MarkerStyle() {}
195 MarkerStyle(char Lead, raw_ostream::Colors Color,
196 const std::string &Note = "", bool FiltersAsError = false)
197 : Lead(Lead), Color(Color), Note(Note), FiltersAsError(FiltersAsError) {
198 assert((!FiltersAsError || !Note.empty()) &&(static_cast <bool> ((!FiltersAsError || !Note.empty())
&& "expected error diagnostic to have note") ? void (
0) : __assert_fail ("(!FiltersAsError || !Note.empty()) && \"expected error diagnostic to have note\""
, "llvm/utils/FileCheck/FileCheck.cpp", 199, __extension__ __PRETTY_FUNCTION__
))
199 "expected error diagnostic to have note")(static_cast <bool> ((!FiltersAsError || !Note.empty())
&& "expected error diagnostic to have note") ? void (
0) : __assert_fail ("(!FiltersAsError || !Note.empty()) && \"expected error diagnostic to have note\""
, "llvm/utils/FileCheck/FileCheck.cpp", 199, __extension__ __PRETTY_FUNCTION__
))
;
200 }
201};
202
203static MarkerStyle GetMarker(FileCheckDiag::MatchType MatchTy) {
204 switch (MatchTy) {
205 case FileCheckDiag::MatchFoundAndExpected:
206 return MarkerStyle('^', raw_ostream::GREEN);
207 case FileCheckDiag::MatchFoundButExcluded:
208 return MarkerStyle('!', raw_ostream::RED, "error: no match expected",
209 /*FiltersAsError=*/true);
210 case FileCheckDiag::MatchFoundButWrongLine:
211 return MarkerStyle('!', raw_ostream::RED, "error: match on wrong line",
212 /*FiltersAsError=*/true);
213 case FileCheckDiag::MatchFoundButDiscarded:
214 return MarkerStyle('!', raw_ostream::CYAN,
215 "discard: overlaps earlier match");
216 case FileCheckDiag::MatchFoundErrorNote:
217 // Note should always be overridden within the FileCheckDiag.
218 return MarkerStyle('!', raw_ostream::RED,
219 "error: unknown error after match",
220 /*FiltersAsError=*/true);
221 case FileCheckDiag::MatchNoneAndExcluded:
222 return MarkerStyle('X', raw_ostream::GREEN);
223 case FileCheckDiag::MatchNoneButExpected:
224 return MarkerStyle('X', raw_ostream::RED, "error: no match found",
225 /*FiltersAsError=*/true);
226 case FileCheckDiag::MatchNoneForInvalidPattern:
227 return MarkerStyle('X', raw_ostream::RED,
228 "error: match failed for invalid pattern",
229 /*FiltersAsError=*/true);
230 case FileCheckDiag::MatchFuzzy:
231 return MarkerStyle('?', raw_ostream::MAGENTA, "possible intended match",
232 /*FiltersAsError=*/true);
233 }
234 llvm_unreachable_internal("unexpected match type");
235}
236
237static void DumpInputAnnotationHelp(raw_ostream &OS) {
238 OS << "The following description was requested by -dump-input=help to\n"
239 << "explain the input dump printed by FileCheck.\n"
240 << "\n"
241 << "Related command-line options:\n"
242 << "\n"
243 << " - -dump-input=<value> enables or disables the input dump\n"
244 << " - -dump-input-filter=<value> filters the input lines\n"
245 << " - -dump-input-context=<N> adjusts the context of filtered lines\n"
246 << " - -v and -vv add more annotations\n"
247 << " - -color forces colors to be enabled both in the dump and below\n"
248 << " - -help documents the above options in more detail\n"
249 << "\n"
250 << "These options can also be set via FILECHECK_OPTS. For example, for\n"
251 << "maximum debugging output on failures:\n"
252 << "\n"
253 << " $ FILECHECK_OPTS='-dump-input-filter=all -vv -color' ninja check\n"
254 << "\n"
255 << "Input dump annotation format:\n"
256 << "\n";
257
258 // Labels for input lines.
259 OS << " - ";
260 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "L:";
261 OS << " labels line number L of the input file\n"
262 << " An extra space is added after each input line to represent"
263 << " the\n"
264 << " newline character\n";
265
266 // Labels for annotation lines.
267 OS << " - ";
268 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L";
269 OS << " labels the only match result for either (1) a pattern of type T"
270 << " from\n"
271 << " line L of the check file if L is an integer or (2) the"
272 << " I-th implicit\n"
273 << " pattern if L is \"imp\" followed by an integer "
274 << "I (index origin one)\n";
275 OS << " - ";
276 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "T:L'N";
277 OS << " labels the Nth match result for such a pattern\n";
278
279 // Markers on annotation lines.
280 OS << " - ";
281 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "^~~";
282 OS << " marks good match (reported if -v)\n"
283 << " - ";
284 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "!~~";
285 OS << " marks bad match, such as:\n"
286 << " - CHECK-NEXT on same line as previous match (error)\n"
287 << " - CHECK-NOT found (error)\n"
288 << " - CHECK-DAG overlapping match (discarded, reported if "
289 << "-vv)\n"
290 << " - ";
291 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "X~~";
292 OS << " marks search range when no match is found, such as:\n"
293 << " - CHECK-NEXT not found (error)\n"
294 << " - CHECK-NOT not found (success, reported if -vv)\n"
295 << " - CHECK-DAG not found after discarded matches (error)\n"
296 << " - ";
297 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "?";
298 OS << " marks fuzzy match when no match is found\n";
299
300 // Elided lines.
301 OS << " - ";
302 WithColor(OS, raw_ostream::SAVEDCOLOR, true) << "...";
303 OS << " indicates elided input lines and annotations, as specified by\n"
304 << " -dump-input-filter and -dump-input-context\n";
305
306 // Colors.
307 OS << " - colors ";
308 WithColor(OS, raw_ostream::GREEN, true) << "success";
309 OS << ", ";
310 WithColor(OS, raw_ostream::RED, true) << "error";
311 OS << ", ";
312 WithColor(OS, raw_ostream::MAGENTA, true) << "fuzzy match";
313 OS << ", ";
314 WithColor(OS, raw_ostream::CYAN, true, false) << "discarded match";
315 OS << ", ";
316 WithColor(OS, raw_ostream::CYAN, true, true) << "unmatched input";
317 OS << "\n";
318}
319
320/// An annotation for a single input line.
321struct InputAnnotation {
322 /// The index of the match result across all checks
323 unsigned DiagIndex;
324 /// The label for this annotation.
325 std::string Label;
326 /// Is this the initial fragment of a diagnostic that has been broken across
327 /// multiple lines?
328 bool IsFirstLine;
329 /// What input line (one-origin indexing) this annotation marks. This might
330 /// be different from the starting line of the original diagnostic if
331 /// !IsFirstLine.
332 unsigned InputLine;
333 /// The column range (one-origin indexing, open end) in which to mark the
334 /// input line. If InputEndCol is UINT_MAX, treat it as the last column
335 /// before the newline.
336 unsigned InputStartCol, InputEndCol;
337 /// The marker to use.
338 MarkerStyle Marker;
339 /// Whether this annotation represents a good match for an expected pattern.
340 bool FoundAndExpectedMatch;
341};
342
343/// Get an abbreviation for the check type.
344static std::string GetCheckTypeAbbreviation(Check::FileCheckType Ty) {
345 switch (Ty) {
346 case Check::CheckPlain:
347 if (Ty.getCount() > 1)
348 return "count";
349 return "check";
350 case Check::CheckNext:
351 return "next";
352 case Check::CheckSame:
353 return "same";
354 case Check::CheckNot:
355 return "not";
356 case Check::CheckDAG:
357 return "dag";
358 case Check::CheckLabel:
359 return "label";
360 case Check::CheckEmpty:
361 return "empty";
362 case Check::CheckComment:
363 return "com";
364 case Check::CheckEOF:
365 return "eof";
366 case Check::CheckBadNot:
367 return "bad-not";
368 case Check::CheckBadCount:
369 return "bad-count";
370 case Check::CheckNone:
371 llvm_unreachable("invalid FileCheckType")::llvm::llvm_unreachable_internal("invalid FileCheckType", "llvm/utils/FileCheck/FileCheck.cpp"
, 371)
;
372 }
373 llvm_unreachable("unknown FileCheckType")::llvm::llvm_unreachable_internal("unknown FileCheckType", "llvm/utils/FileCheck/FileCheck.cpp"
, 373)
;
374}
375
376static void
377BuildInputAnnotations(const SourceMgr &SM, unsigned CheckFileBufferID,
378 const std::pair<unsigned, unsigned> &ImpPatBufferIDRange,
379 const std::vector<FileCheckDiag> &Diags,
380 std::vector<InputAnnotation> &Annotations,
381 unsigned &LabelWidth) {
382 struct CompareSMLoc {
383 bool operator()(const SMLoc &LHS, const SMLoc &RHS) const {
384 return LHS.getPointer() < RHS.getPointer();
385 }
386 };
387 // How many diagnostics does each pattern have?
388 std::map<SMLoc, unsigned, CompareSMLoc> DiagCountPerPattern;
389 for (auto Diag : Diags)
390 ++DiagCountPerPattern[Diag.CheckLoc];
391 // How many diagnostics have we seen so far per pattern?
392 std::map<SMLoc, unsigned, CompareSMLoc> DiagIndexPerPattern;
393 // How many total diagnostics have we seen so far?
394 unsigned DiagIndex = 0;
395 // What's the widest label?
396 LabelWidth = 0;
397 for (auto DiagItr = Diags.begin(), DiagEnd = Diags.end(); DiagItr != DiagEnd;
398 ++DiagItr) {
399 InputAnnotation A;
400 A.DiagIndex = DiagIndex++;
401
402 // Build label, which uniquely identifies this check result.
403 unsigned CheckBufferID = SM.FindBufferContainingLoc(DiagItr->CheckLoc);
404 auto CheckLineAndCol =
405 SM.getLineAndColumn(DiagItr->CheckLoc, CheckBufferID);
406 llvm::raw_string_ostream Label(A.Label);
407 Label << GetCheckTypeAbbreviation(DiagItr->CheckTy) << ":";
408 if (CheckBufferID == CheckFileBufferID)
409 Label << CheckLineAndCol.first;
410 else if (ImpPatBufferIDRange.first <= CheckBufferID &&
411 CheckBufferID < ImpPatBufferIDRange.second)
412 Label << "imp" << (CheckBufferID - ImpPatBufferIDRange.first + 1);
413 else
414 llvm_unreachable("expected diagnostic's check location to be either in "::llvm::llvm_unreachable_internal("expected diagnostic's check location to be either in "
"the check file or for an implicit pattern", "llvm/utils/FileCheck/FileCheck.cpp"
, 415)
415 "the check file or for an implicit pattern")::llvm::llvm_unreachable_internal("expected diagnostic's check location to be either in "
"the check file or for an implicit pattern", "llvm/utils/FileCheck/FileCheck.cpp"
, 415)
;
416 if (DiagCountPerPattern[DiagItr->CheckLoc] > 1)
417 Label << "'" << DiagIndexPerPattern[DiagItr->CheckLoc]++;
418 LabelWidth = std::max((std::string::size_type)LabelWidth, A.Label.size());
419
420 A.Marker = GetMarker(DiagItr->MatchTy);
421 if (!DiagItr->Note.empty()) {
422 A.Marker.Note = DiagItr->Note;
423 // It's less confusing if notes that don't actually have ranges don't have
424 // markers. For example, a marker for 'with "VAR" equal to "5"' would
425 // seem to indicate where "VAR" matches, but the location we actually have
426 // for the marker simply points to the start of the match/search range for
427 // the full pattern of which the substitution is potentially just one
428 // component.
429 if (DiagItr->InputStartLine == DiagItr->InputEndLine &&
430 DiagItr->InputStartCol == DiagItr->InputEndCol)
431 A.Marker.Lead = ' ';
432 }
433 if (DiagItr->MatchTy == FileCheckDiag::MatchFoundErrorNote) {
434 assert(!DiagItr->Note.empty() &&(static_cast <bool> (!DiagItr->Note.empty() &&
"expected custom note for MatchFoundErrorNote") ? void (0) :
__assert_fail ("!DiagItr->Note.empty() && \"expected custom note for MatchFoundErrorNote\""
, "llvm/utils/FileCheck/FileCheck.cpp", 435, __extension__ __PRETTY_FUNCTION__
))
435 "expected custom note for MatchFoundErrorNote")(static_cast <bool> (!DiagItr->Note.empty() &&
"expected custom note for MatchFoundErrorNote") ? void (0) :
__assert_fail ("!DiagItr->Note.empty() && \"expected custom note for MatchFoundErrorNote\""
, "llvm/utils/FileCheck/FileCheck.cpp", 435, __extension__ __PRETTY_FUNCTION__
))
;
436 A.Marker.Note = "error: " + A.Marker.Note;
437 }
438 A.FoundAndExpectedMatch =
439 DiagItr->MatchTy == FileCheckDiag::MatchFoundAndExpected;
440
441 // Compute the mark location, and break annotation into multiple
442 // annotations if it spans multiple lines.
443 A.IsFirstLine = true;
444 A.InputLine = DiagItr->InputStartLine;
445 A.InputStartCol = DiagItr->InputStartCol;
446 if (DiagItr->InputStartLine == DiagItr->InputEndLine) {
447 // Sometimes ranges are empty in order to indicate a specific point, but
448 // that would mean nothing would be marked, so adjust the range to
449 // include the following character.
450 A.InputEndCol =
451 std::max(DiagItr->InputStartCol + 1, DiagItr->InputEndCol);
452 Annotations.push_back(A);
453 } else {
454 assert(DiagItr->InputStartLine < DiagItr->InputEndLine &&(static_cast <bool> (DiagItr->InputStartLine < DiagItr
->InputEndLine && "expected input range not to be inverted"
) ? void (0) : __assert_fail ("DiagItr->InputStartLine < DiagItr->InputEndLine && \"expected input range not to be inverted\""
, "llvm/utils/FileCheck/FileCheck.cpp", 455, __extension__ __PRETTY_FUNCTION__
))
455 "expected input range not to be inverted")(static_cast <bool> (DiagItr->InputStartLine < DiagItr
->InputEndLine && "expected input range not to be inverted"
) ? void (0) : __assert_fail ("DiagItr->InputStartLine < DiagItr->InputEndLine && \"expected input range not to be inverted\""
, "llvm/utils/FileCheck/FileCheck.cpp", 455, __extension__ __PRETTY_FUNCTION__
))
;
456 A.InputEndCol = UINT_MAX(2147483647 *2U +1U);
457 Annotations.push_back(A);
458 for (unsigned L = DiagItr->InputStartLine + 1, E = DiagItr->InputEndLine;
459 L <= E; ++L) {
460 // If a range ends before the first column on a line, then it has no
461 // characters on that line, so there's nothing to render.
462 if (DiagItr->InputEndCol == 1 && L == E)
463 break;
464 InputAnnotation B;
465 B.DiagIndex = A.DiagIndex;
466 B.Label = A.Label;
467 B.IsFirstLine = false;
468 B.InputLine = L;
469 B.Marker = A.Marker;
470 B.Marker.Lead = '~';
471 B.Marker.Note = "";
472 B.InputStartCol = 1;
473 if (L != E)
474 B.InputEndCol = UINT_MAX(2147483647 *2U +1U);
475 else
476 B.InputEndCol = DiagItr->InputEndCol;
477 B.FoundAndExpectedMatch = A.FoundAndExpectedMatch;
478 Annotations.push_back(B);
479 }
480 }
481 }
482}
483
484static unsigned FindInputLineInFilter(
485 DumpInputFilterValue DumpInputFilter, unsigned CurInputLine,
486 const std::vector<InputAnnotation>::iterator &AnnotationBeg,
487 const std::vector<InputAnnotation>::iterator &AnnotationEnd) {
488 if (DumpInputFilter == DumpInputFilterAll)
489 return CurInputLine;
490 for (auto AnnotationItr = AnnotationBeg; AnnotationItr != AnnotationEnd;
491 ++AnnotationItr) {
492 switch (DumpInputFilter) {
493 case DumpInputFilterAll:
494 llvm_unreachable("unexpected DumpInputFilterAll")::llvm::llvm_unreachable_internal("unexpected DumpInputFilterAll"
, "llvm/utils/FileCheck/FileCheck.cpp", 494)
;
495 break;
496 case DumpInputFilterAnnotationFull:
497 return AnnotationItr->InputLine;
498 case DumpInputFilterAnnotation:
499 if (AnnotationItr->IsFirstLine)
500 return AnnotationItr->InputLine;
501 break;
502 case DumpInputFilterError:
503 if (AnnotationItr->IsFirstLine && AnnotationItr->Marker.FiltersAsError)
504 return AnnotationItr->InputLine;
505 break;
506 }
507 }
508 return UINT_MAX(2147483647 *2U +1U);
509}
510
511/// To OS, print a vertical ellipsis (right-justified at LabelWidth) if it would
512/// occupy less lines than ElidedLines, but print ElidedLines otherwise. Either
513/// way, clear ElidedLines. Thus, if ElidedLines is empty, do nothing.
514static void DumpEllipsisOrElidedLines(raw_ostream &OS, std::string &ElidedLines,
515 unsigned LabelWidth) {
516 if (ElidedLines.empty())
517 return;
518 unsigned EllipsisLines = 3;
519 if (EllipsisLines < StringRef(ElidedLines).count('\n')) {
520 for (unsigned i = 0; i < EllipsisLines; ++i) {
521 WithColor(OS, raw_ostream::BLACK, /*Bold=*/true)
522 << right_justify(".", LabelWidth);
523 OS << '\n';
524 }
525 } else
526 OS << ElidedLines;
527 ElidedLines.clear();
528}
529
530static void DumpAnnotatedInput(raw_ostream &OS, const FileCheckRequest &Req,
531 DumpInputFilterValue DumpInputFilter,
532 unsigned DumpInputContext,
533 StringRef InputFileText,
534 std::vector<InputAnnotation> &Annotations,
535 unsigned LabelWidth) {
536 OS << "Input was:\n<<<<<<\n";
537
538 // Sort annotations.
539 llvm::sort(Annotations,
540 [](const InputAnnotation &A, const InputAnnotation &B) {
541 // 1. Sort annotations in the order of the input lines.
542 //
543 // This makes it easier to find relevant annotations while
544 // iterating input lines in the implementation below. FileCheck
545 // does not always produce diagnostics in the order of input
546 // lines due to, for example, CHECK-DAG and CHECK-NOT.
547 if (A.InputLine != B.InputLine)
548 return A.InputLine < B.InputLine;
549 // 2. Sort annotations in the temporal order FileCheck produced
550 // their associated diagnostics.
551 //
552 // This sort offers several benefits:
553 //
554 // A. On a single input line, the order of annotations reflects
555 // the FileCheck logic for processing directives/patterns.
556 // This can be helpful in understanding cases in which the
557 // order of the associated directives/patterns in the check
558 // file or on the command line either (i) does not match the
559 // temporal order in which FileCheck looks for matches for the
560 // directives/patterns (due to, for example, CHECK-LABEL,
561 // CHECK-NOT, or `--implicit-check-not`) or (ii) does match
562 // that order but does not match the order of those
563 // diagnostics along an input line (due to, for example,
564 // CHECK-DAG).
565 //
566 // On the other hand, because our presentation format presents
567 // input lines in order, there's no clear way to offer the
568 // same benefit across input lines. For consistency, it might
569 // then seem worthwhile to have annotations on a single line
570 // also sorted in input order (that is, by input column).
571 // However, in practice, this appears to be more confusing
572 // than helpful. Perhaps it's intuitive to expect annotations
573 // to be listed in the temporal order in which they were
574 // produced except in cases the presentation format obviously
575 // and inherently cannot support it (that is, across input
576 // lines).
577 //
578 // B. When diagnostics' annotations are split among multiple
579 // input lines, the user must track them from one input line
580 // to the next. One property of the sort chosen here is that
581 // it facilitates the user in this regard by ensuring the
582 // following: when comparing any two input lines, a
583 // diagnostic's annotations are sorted in the same position
584 // relative to all other diagnostics' annotations.
585 return A.DiagIndex < B.DiagIndex;
586 });
587
588 // Compute the width of the label column.
589 const unsigned char *InputFilePtr = InputFileText.bytes_begin(),
590 *InputFileEnd = InputFileText.bytes_end();
591 unsigned LineCount = InputFileText.count('\n');
592 if (InputFileEnd[-1] != '\n')
593 ++LineCount;
594 unsigned LineNoWidth = std::log10(LineCount) + 1;
595 // +3 below adds spaces (1) to the left of the (right-aligned) line numbers
596 // on input lines and (2) to the right of the (left-aligned) labels on
597 // annotation lines so that input lines and annotation lines are more
598 // visually distinct. For example, the spaces on the annotation lines ensure
599 // that input line numbers and check directive line numbers never align
600 // horizontally. Those line numbers might not even be for the same file.
601 // One space would be enough to achieve that, but more makes it even easier
602 // to see.
603 LabelWidth = std::max(LabelWidth, LineNoWidth) + 3;
604
605 // Print annotated input lines.
606 unsigned PrevLineInFilter = 0; // 0 means none so far
607 unsigned NextLineInFilter = 0; // 0 means uncomputed, UINT_MAX means none
608 std::string ElidedLines;
609 raw_string_ostream ElidedLinesOS(ElidedLines);
610 ColorMode TheColorMode =
611 WithColor(OS).colorsEnabled() ? ColorMode::Enable : ColorMode::Disable;
612 if (TheColorMode == ColorMode::Enable)
613 ElidedLinesOS.enable_colors(true);
614 auto AnnotationItr = Annotations.begin(), AnnotationEnd = Annotations.end();
615 for (unsigned Line = 1;
616 InputFilePtr != InputFileEnd || AnnotationItr != AnnotationEnd;
617 ++Line) {
618 const unsigned char *InputFileLine = InputFilePtr;
619
620 // Compute the previous and next line included by the filter.
621 if (NextLineInFilter < Line)
622 NextLineInFilter = FindInputLineInFilter(DumpInputFilter, Line,
623 AnnotationItr, AnnotationEnd);
624 assert(NextLineInFilter && "expected NextLineInFilter to be computed")(static_cast <bool> (NextLineInFilter && "expected NextLineInFilter to be computed"
) ? void (0) : __assert_fail ("NextLineInFilter && \"expected NextLineInFilter to be computed\""
, "llvm/utils/FileCheck/FileCheck.cpp", 624, __extension__ __PRETTY_FUNCTION__
))
;
625 if (NextLineInFilter == Line)
626 PrevLineInFilter = Line;
627
628 // Elide this input line and its annotations if it's not within the
629 // context specified by -dump-input-context of an input line included by
630 // -dump-input-filter. However, in case the resulting ellipsis would occupy
631 // more lines than the input lines and annotations it elides, buffer the
632 // elided lines and annotations so we can print them instead.
633 raw_ostream *LineOS = &OS;
Value stored to 'LineOS' during its initialization is never read
634 if ((!PrevLineInFilter || PrevLineInFilter + DumpInputContext < Line) &&
635 (NextLineInFilter == UINT_MAX(2147483647 *2U +1U) ||
636 Line + DumpInputContext < NextLineInFilter))
637 LineOS = &ElidedLinesOS;
638 else {
639 LineOS = &OS;
640 DumpEllipsisOrElidedLines(OS, ElidedLinesOS.str(), LabelWidth);
641 }
642
643 // Print right-aligned line number.
644 WithColor(*LineOS, raw_ostream::BLACK, /*Bold=*/true, /*BF=*/false,
645 TheColorMode)
646 << format_decimal(Line, LabelWidth) << ": ";
647
648 // For the case where -v and colors are enabled, find the annotations for
649 // good matches for expected patterns in order to highlight everything
650 // else in the line. There are no such annotations if -v is disabled.
651 std::vector<InputAnnotation> FoundAndExpectedMatches;
652 if (Req.Verbose && TheColorMode == ColorMode::Enable) {
653 for (auto I = AnnotationItr; I != AnnotationEnd && I->InputLine == Line;
654 ++I) {
655 if (I->FoundAndExpectedMatch)
656 FoundAndExpectedMatches.push_back(*I);
657 }
658 }
659
660 // Print numbered line with highlighting where there are no matches for
661 // expected patterns.
662 bool Newline = false;
663 {
664 WithColor COS(*LineOS, raw_ostream::SAVEDCOLOR, /*Bold=*/false,
665 /*BG=*/false, TheColorMode);
666 bool InMatch = false;
667 if (Req.Verbose)
668 COS.changeColor(raw_ostream::CYAN, true, true);
669 for (unsigned Col = 1; InputFilePtr != InputFileEnd && !Newline; ++Col) {
670 bool WasInMatch = InMatch;
671 InMatch = false;
672 for (auto M : FoundAndExpectedMatches) {
673 if (M.InputStartCol <= Col && Col < M.InputEndCol) {
674 InMatch = true;
675 break;
676 }
677 }
678 if (!WasInMatch && InMatch)
679 COS.resetColor();
680 else if (WasInMatch && !InMatch)
681 COS.changeColor(raw_ostream::CYAN, true, true);
682 if (*InputFilePtr == '\n') {
683 Newline = true;
684 COS << ' ';
685 } else
686 COS << *InputFilePtr;
687 ++InputFilePtr;
688 }
689 }
690 *LineOS << '\n';
691 unsigned InputLineWidth = InputFilePtr - InputFileLine;
692
693 // Print any annotations.
694 while (AnnotationItr != AnnotationEnd &&
695 AnnotationItr->InputLine == Line) {
696 WithColor COS(*LineOS, AnnotationItr->Marker.Color, /*Bold=*/true,
697 /*BG=*/false, TheColorMode);
698 // The two spaces below are where the ": " appears on input lines.
699 COS << left_justify(AnnotationItr->Label, LabelWidth) << " ";
700 unsigned Col;
701 for (Col = 1; Col < AnnotationItr->InputStartCol; ++Col)
702 COS << ' ';
703 COS << AnnotationItr->Marker.Lead;
704 // If InputEndCol=UINT_MAX, stop at InputLineWidth.
705 for (++Col; Col < AnnotationItr->InputEndCol && Col <= InputLineWidth;
706 ++Col)
707 COS << '~';
708 const std::string &Note = AnnotationItr->Marker.Note;
709 if (!Note.empty()) {
710 // Put the note at the end of the input line. If we were to instead
711 // put the note right after the marker, subsequent annotations for the
712 // same input line might appear to mark this note instead of the input
713 // line.
714 for (; Col <= InputLineWidth; ++Col)
715 COS << ' ';
716 COS << ' ' << Note;
717 }
718 COS << '\n';
719 ++AnnotationItr;
720 }
721 }
722 DumpEllipsisOrElidedLines(OS, ElidedLinesOS.str(), LabelWidth);
723
724 OS << ">>>>>>\n";
725}
726
727int main(int argc, char **argv) {
728 // Enable use of ANSI color codes because FileCheck is using them to
729 // highlight text.
730 llvm::sys::Process::UseANSIEscapeCodes(true);
731
732 InitLLVM X(argc, argv);
733 cl::ParseCommandLineOptions(argc, argv, /*Overview*/ "", /*Errs*/ nullptr,
734 "FILECHECK_OPTS");
735
736 // Select -dump-input* values. The -help documentation specifies the default
737 // value and which value to choose if an option is specified multiple times.
738 // In the latter case, the general rule of thumb is to choose the value that
739 // provides the most information.
740 DumpInputValue DumpInput =
741 DumpInputs.empty()
742 ? DumpInputFail
743 : *std::max_element(DumpInputs.begin(), DumpInputs.end());
744 DumpInputFilterValue DumpInputFilter;
745 if (DumpInputFilters.empty())
746 DumpInputFilter = DumpInput == DumpInputAlways ? DumpInputFilterAll
747 : DumpInputFilterError;
748 else
749 DumpInputFilter =
750 *std::max_element(DumpInputFilters.begin(), DumpInputFilters.end());
751 unsigned DumpInputContext = DumpInputContexts.empty()
752 ? 5
753 : *std::max_element(DumpInputContexts.begin(),
754 DumpInputContexts.end());
755
756 if (DumpInput == DumpInputHelp) {
757 DumpInputAnnotationHelp(outs());
758 return 0;
759 }
760 if (CheckFilename.empty()) {
761 errs() << "<check-file> not specified\n";
762 return 2;
763 }
764
765 FileCheckRequest Req;
766 append_range(Req.CheckPrefixes, CheckPrefixes);
767
768 append_range(Req.CommentPrefixes, CommentPrefixes);
769
770 append_range(Req.ImplicitCheckNot, ImplicitCheckNot);
771
772 bool GlobalDefineError = false;
773 for (StringRef G : GlobalDefines) {
774 size_t EqIdx = G.find('=');
775 if (EqIdx == std::string::npos) {
776 errs() << "Missing equal sign in command-line definition '-D" << G
777 << "'\n";
778 GlobalDefineError = true;
779 continue;
780 }
781 if (EqIdx == 0) {
782 errs() << "Missing variable name in command-line definition '-D" << G
783 << "'\n";
784 GlobalDefineError = true;
785 continue;
786 }
787 Req.GlobalDefines.push_back(G);
788 }
789 if (GlobalDefineError)
790 return 2;
791
792 Req.AllowEmptyInput = AllowEmptyInput;
793 Req.AllowUnusedPrefixes = AllowUnusedPrefixes;
794 Req.EnableVarScope = EnableVarScope;
795 Req.AllowDeprecatedDagOverlap = AllowDeprecatedDagOverlap;
796 Req.Verbose = Verbose;
797 Req.VerboseVerbose = VerboseVerbose;
798 Req.NoCanonicalizeWhiteSpace = NoCanonicalizeWhiteSpace;
799 Req.MatchFullLines = MatchFullLines;
800 Req.IgnoreCase = IgnoreCase;
801
802 if (VerboseVerbose)
803 Req.Verbose = true;
804
805 FileCheck FC(Req);
806 if (!FC.ValidateCheckPrefixes())
807 return 2;
808
809 Regex PrefixRE = FC.buildCheckPrefixRegex();
810 std::string REError;
811 if (!PrefixRE.isValid(REError)) {
812 errs() << "Unable to combine check-prefix strings into a prefix regular "
813 "expression! This is likely a bug in FileCheck's verification of "
814 "the check-prefix strings. Regular expression parsing failed "
815 "with the following error: "
816 << REError << "\n";
817 return 2;
818 }
819
820 SourceMgr SM;
821
822 // Read the expected strings from the check file.
823 ErrorOr<std::unique_ptr<MemoryBuffer>> CheckFileOrErr =
824 MemoryBuffer::getFileOrSTDIN(CheckFilename, /*IsText=*/true);
825 if (std::error_code EC = CheckFileOrErr.getError()) {
826 errs() << "Could not open check file '" << CheckFilename
827 << "': " << EC.message() << '\n';
828 return 2;
829 }
830 MemoryBuffer &CheckFile = *CheckFileOrErr.get();
831
832 SmallString<4096> CheckFileBuffer;
833 StringRef CheckFileText = FC.CanonicalizeFile(CheckFile, CheckFileBuffer);
834
835 unsigned CheckFileBufferID =
836 SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
837 CheckFileText, CheckFile.getBufferIdentifier()),
838 SMLoc());
839
840 std::pair<unsigned, unsigned> ImpPatBufferIDRange;
841 if (FC.readCheckFile(SM, CheckFileText, PrefixRE, &ImpPatBufferIDRange))
842 return 2;
843
844 // Open the file to check and add it to SourceMgr.
845 ErrorOr<std::unique_ptr<MemoryBuffer>> InputFileOrErr =
846 MemoryBuffer::getFileOrSTDIN(InputFilename, /*IsText=*/true);
847 if (InputFilename == "-")
848 InputFilename = "<stdin>"; // Overwrite for improved diagnostic messages
849 if (std::error_code EC = InputFileOrErr.getError()) {
850 errs() << "Could not open input file '" << InputFilename
851 << "': " << EC.message() << '\n';
852 return 2;
853 }
854 MemoryBuffer &InputFile = *InputFileOrErr.get();
855
856 if (InputFile.getBufferSize() == 0 && !AllowEmptyInput) {
857 errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";
858 DumpCommandLine(argc, argv);
859 return 2;
860 }
861
862 SmallString<4096> InputFileBuffer;
863 StringRef InputFileText = FC.CanonicalizeFile(InputFile, InputFileBuffer);
864
865 SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
866 InputFileText, InputFile.getBufferIdentifier()),
867 SMLoc());
868
869 std::vector<FileCheckDiag> Diags;
870 int ExitCode = FC.checkInput(SM, InputFileText,
871 DumpInput == DumpInputNever ? nullptr : &Diags)
872 ? EXIT_SUCCESS0
873 : 1;
874 if (DumpInput == DumpInputAlways ||
875 (ExitCode == 1 && DumpInput == DumpInputFail)) {
876 errs() << "\n"
877 << "Input file: " << InputFilename << "\n"
878 << "Check file: " << CheckFilename << "\n"
879 << "\n"
880 << "-dump-input=help explains the following input dump.\n"
881 << "\n";
882 std::vector<InputAnnotation> Annotations;
883 unsigned LabelWidth;
884 BuildInputAnnotations(SM, CheckFileBufferID, ImpPatBufferIDRange, Diags,
885 Annotations, LabelWidth);
886 DumpAnnotatedInput(errs(), Req, DumpInputFilter, DumpInputContext,
887 InputFileText, Annotations, LabelWidth);
888 }
889
890 return ExitCode;
891}