1FILECHECK(1) LLVM FILECHECK(1)
2
6 FileCheck - Flexible pattern matching file verifier
7
9 FileCheck match-filename [--check-prefix=XXX] [--strict-whitespace]
10
12 FileCheck reads two files (one from standard input, and one specified
13 on the command line) and uses one to verify the other. This behavior
14 is particularly useful for the testsuite, which wants to verify that
15 the output of some tool (e.g. llc) contains the expected information
16 (for example, a movsd from esp or whatever is interesting). This is
17 similar to using grep, but it is optimized for matching multiple dif‐
18 ferent inputs in one file in a specific order.
19 The match-filename file specifies the file that contains the patterns
21 to match. The file to verify is read from standard input unless the
22 --input-file option is used.
23
25 Options are parsed from the environment variable FILECHECK_OPTS and
26 from the command line.
27 -help Print a summary of command line options.
29 --check-prefix prefix
31 FileCheck searches the contents of match-filename for patterns
32 to match. By default, these patterns are prefixed with
33 "CHECK:". If you'd like to use a different prefix (e.g. because
34 the same input file is checking multiple different tool or op‐
35 tions), the --check-prefix argument allows you to specify one or
36 more prefixes to match. Multiple prefixes are useful for tests
37 which might change for different run options, but most lines re‐
38 main the same.
39 --check-prefixes prefix1,prefix2,...
41 An alias of --check-prefix that allows multiple prefixes to be
42 specified as a comma separated list.
43 --input-file filename
45 File to check (defaults to stdin).
46 --match-full-lines
48 By default, FileCheck allows matches of anywhere on a line. This
49 option will require all positive matches to cover an entire
50 line. Leading and trailing whitespace is ignored, unless
51 --strict-whitespace is also specified. (Note: negative matches
52 from CHECK-NOT are not affected by this option!)
53 Passing this option is equivalent to inserting {{^ *}} or {{^}}
55 before, and {{ *$}} or {{$}} after every positive check pattern.
56 --strict-whitespace
58 By default, FileCheck canonicalizes input horizontal whitespace
59 (spaces and tabs) which causes it to ignore these differences (a
60 space will match a tab). The --strict-whitespace argument dis‐
61 ables this behavior. End-of-line sequences are canonicalized to
62 UNIX-style \n in all modes.
63 --ignore-case
65 By default, FileCheck uses case-sensitive matching. This option
66 causes FileCheck to use case-insensitive matching.
67 --implicit-check-not check-pattern
69 Adds implicit negative checks for the specified patterns between
70 positive checks. The option allows writing stricter tests with‐
71 out stuffing them with CHECK-NOTs.
72 For example, "--implicit-check-not warning:" can be useful when
74 testing diagnostic messages from tools that don't have an option
75 similar to clang -verify. With this option FileCheck will verify
76 that input does not contain warnings not covered by any CHECK:
77 patterns.
78 --dump-input <mode>
80 Dump input to stderr, adding annotations representing currently
81 enabled diagnostics. Do this either 'always', on 'fail', or
82 'never'. Specify 'help' to explain the dump format and quit.
83 --dump-input-on-failure
85 When the check fails, dump all of the original input. This op‐
86 tion is deprecated in favor of --dump-input=fail.
87 --enable-var-scope
89 Enables scope for regex variables.
90 Variables with names that start with $ are considered global and
92 remain set throughout the file.
93 All other variables get undefined after each encountered
95 CHECK-LABEL.
96 -D<VAR=VALUE>
98 Sets a filecheck pattern variable VAR with value VALUE that can
99 be used in CHECK: lines.
100 -D#<NUMVAR>=<NUMERIC EXPRESSION>
102 Sets a filecheck numeric variable NUMVAR to the result of evalu‐
103 ating <NUMERIC EXPRESSION> that can be used in CHECK: lines. See
104 section FileCheck Numeric Variables and Expressions for details
105 on supported numeric expressions.
106 -version
108 Show the version number of this program.
109 -v Print good directive pattern matches. However, if -in‐
111 put-dump=fail or -input-dump=always, add those matches as input
112 annotations instead.
113 -vv Print information helpful in diagnosing internal FileCheck is‐
115 sues, such as discarded overlapping CHECK-DAG: matches, implicit
116 EOF pattern matches, and CHECK-NOT: patterns that do not have
117 matches. Implies -v. However, if -input-dump=fail or -in‐
118 put-dump=always, just add that information as input annotations
119 instead.
120 --allow-deprecated-dag-overlap
122 Enable overlapping among matches in a group of consecutive
123 CHECK-DAG: directives. This option is deprecated and is only
124 provided for convenience as old tests are migrated to the new
125 non-overlapping CHECK-DAG: implementation.
126 --color
128 Use colors in output (autodetected by default).
129
131 If FileCheck verifies that the file matches the expected contents, it
132 exits with 0. Otherwise, if not, or if an error occurs, it will exit
133 with a non-zero value.
134
136 FileCheck is typically used from LLVM regression tests, being invoked
137 on the RUN line of the test. A simple example of using FileCheck from
138 a RUN line looks like this:
139 ; RUN: llvm-as < %s | llc -march=x86-64 | FileCheck %s
141 This syntax says to pipe the current file ("%s") into llvm-as, pipe
143 that into llc, then pipe the output of llc into FileCheck. This means
144 that FileCheck will be verifying its standard input (the llc output)
145 against the filename argument specified (the original .ll file speci‐
146 fied by "%s"). To see how this works, let's look at the rest of the
147 .ll file (after the RUN line):
148 define void @sub1(i32* %p, i32 %v) {
150 entry:
151 ; CHECK: sub1:
152 ; CHECK: subl
153 %0 = tail call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %p, i32 %v)
154 ret void
155 }
156 define void @inc4(i64* %p) {
158 entry:
159 ; CHECK: inc4:
160 ; CHECK: incq
161 %0 = tail call i64 @llvm.atomic.load.add.i64.p0i64(i64* %p, i64 1)
162 ret void
163 }
164 Here you can see some "CHECK:" lines specified in comments. Now you
166 can see how the file is piped into llvm-as, then llc, and the machine
167 code output is what we are verifying. FileCheck checks the machine
168 code output to verify that it matches what the "CHECK:" lines specify.
169 The syntax of the "CHECK:" lines is very simple: they are fixed strings
171 that must occur in order. FileCheck defaults to ignoring horizontal
172 whitespace differences (e.g. a space is allowed to match a tab) but
173 otherwise, the contents of the "CHECK:" line is required to match some
174 thing in the test file exactly.
175 One nice thing about FileCheck (compared to grep) is that it allows
177 merging test cases together into logical groups. For example, because
178 the test above is checking for the "sub1:" and "inc4:" labels, it will
179 not match unless there is a "subl" in between those labels. If it ex‐
180 isted somewhere else in the file, that would not count: "grep subl"
181 matches if "subl" exists anywhere in the file.
182 The FileCheck -check-prefix option
184 The FileCheck -check-prefix option allows multiple test configurations
185 to be driven from one .ll file. This is useful in many circumstances,
186 for example, testing different architectural variants with llc. Here's
187 a simple example:
188 ; RUN: llvm-as < %s | llc -mtriple=i686-apple-darwin9 -mattr=sse41 \
190 ; RUN: | FileCheck %s -check-prefix=X32
191 ; RUN: llvm-as < %s | llc -mtriple=x86_64-apple-darwin9 -mattr=sse41 \
192 ; RUN: | FileCheck %s -check-prefix=X64
193 define <4 x i32> @pinsrd_1(i32 %s, <4 x i32> %tmp) nounwind {
195 %tmp1 = insertelement <4 x i32>; %tmp, i32 %s, i32 1
196 ret <4 x i32> %tmp1
197 ; X32: pinsrd_1:
198 ; X32: pinsrd $1, 4(%esp), %xmm0
199 ; X64: pinsrd_1:
201 ; X64: pinsrd $1, %edi, %xmm0
202 }
203 In this case, we're testing that we get the expected code generation
205 with both 32-bit and 64-bit code generation.
206 The CHECK-NEXT: directive
208 Sometimes you want to match lines and would like to verify that matches
209 happen on exactly consecutive lines with no other lines in between
210 them. In this case, you can use "CHECK:" and "CHECK-NEXT:" directives
211 to specify this. If you specified a custom check prefix, just use
212 "<PREFIX>-NEXT:". For example, something like this works as you'd ex‐
213 pect:
214 define void @t2(<2 x double>* %r, <2 x double>* %A, double %B) {
216 %tmp3 = load <2 x double>* %A, align 16
217 %tmp7 = insertelement <2 x double> undef, double %B, i32 0
218 %tmp9 = shufflevector <2 x double> %tmp3,
219 <2 x double> %tmp7,
220 <2 x i32> < i32 0, i32 2 >
221 store <2 x double> %tmp9, <2 x double>* %r, align 16
222 ret void
223 ; CHECK: t2:
225 ; CHECK: movl 8(%esp), %eax
226 ; CHECK-NEXT: movapd (%eax), %xmm0
227 ; CHECK-NEXT: movhpd 12(%esp), %xmm0
228 ; CHECK-NEXT: movl 4(%esp), %eax
229 ; CHECK-NEXT: movapd %xmm0, (%eax)
230 ; CHECK-NEXT: ret
231 }
232 "CHECK-NEXT:" directives reject the input unless there is exactly one
234 newline between it and the previous directive. A "CHECK-NEXT:" cannot
235 be the first directive in a file.
236 The CHECK-SAME: directive
238 Sometimes you want to match lines and would like to verify that matches
239 happen on the same line as the previous match. In this case, you can
240 use "CHECK:" and "CHECK-SAME:" directives to specify this. If you
241 specified a custom check prefix, just use "<PREFIX>-SAME:".
242 "CHECK-SAME:" is particularly powerful in conjunction with "CHECK-NOT:"
244 (described below).
245 For example, the following works like you'd expect:
247 !0 = !DILocation(line: 5, scope: !1, inlinedAt: !2)
249 ; CHECK: !DILocation(line: 5,
251 ; CHECK-NOT: column:
252 ; CHECK-SAME: scope: ![[SCOPE:[0-9]+]]
253 "CHECK-SAME:" directives reject the input if there are any newlines be‐
255 tween it and the previous directive. A "CHECK-SAME:" cannot be the
256 first directive in a file.
257 The CHECK-EMPTY: directive
259 If you need to check that the next line has nothing on it, not even
260 whitespace, you can use the "CHECK-EMPTY:" directive.
261 declare void @foo()
263 declare void @bar()
265 ; CHECK: foo
266 ; CHECK-EMPTY:
267 ; CHECK-NEXT: bar
268 Just like "CHECK-NEXT:" the directive will fail if there is more than
270 one newline before it finds the next blank line, and it cannot be the
271 first directive in a file.
272 The CHECK-NOT: directive
274 The "CHECK-NOT:" directive is used to verify that a string doesn't oc‐
275 cur between two matches (or before the first match, or after the last
276 match). For example, to verify that a load is removed by a transforma‐
277 tion, a test like this can be used:
278 define i8 @coerce_offset0(i32 %V, i32* %P) {
280 store i32 %V, i32* %P
281 %P2 = bitcast i32* %P to i8*
283 %P3 = getelementptr i8* %P2, i32 2
284 %A = load i8* %P3
286 ret i8 %A
287 ; CHECK: @coerce_offset0
288 ; CHECK-NOT: load
289 ; CHECK: ret i8
290 }
291 The CHECK-COUNT: directive
293 If you need to match multiple lines with the same pattern over and over
294 again you can repeat a plain CHECK: as many times as needed. If that
295 looks too boring you can instead use a counted check
296 "CHECK-COUNT-<num>:", where <num> is a positive decimal number. It will
297 match the pattern exactly <num> times, no more and no less. If you
298 specified a custom check prefix, just use "<PREFIX>-COUNT-<num>:" for
299 the same effect. Here is a simple example:
300 Loop at depth 1
302 Loop at depth 1
303 Loop at depth 1
304 Loop at depth 1
305 Loop at depth 2
306 Loop at depth 3
307 ; CHECK-COUNT-6: Loop at depth {{[0-9]+}}
309 ; CHECK-NOT: Loop at depth {{[0-9]+}}
310 The CHECK-DAG: directive
312 If it's necessary to match strings that don't occur in a strictly se‐
313 quential order, "CHECK-DAG:" could be used to verify them between two
314 matches (or before the first match, or after the last match). For exam‐
315 ple, clang emits vtable globals in reverse order. Using CHECK-DAG:, we
316 can keep the checks in the natural order:
317 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
319 struct Foo { virtual void method(); };
321 Foo f; // emit vtable
322 // CHECK-DAG: @_ZTV3Foo =
323 struct Bar { virtual void method(); };
325 Bar b;
326 // CHECK-DAG: @_ZTV3Bar =
327 CHECK-NOT: directives could be mixed with CHECK-DAG: directives to ex‐
329 clude strings between the surrounding CHECK-DAG: directives. As a re‐
330 sult, the surrounding CHECK-DAG: directives cannot be reordered, i.e.
331 all occurrences matching CHECK-DAG: before CHECK-NOT: must not fall be‐
332 hind occurrences matching CHECK-DAG: after CHECK-NOT:. For example,
333 ; CHECK-DAG: BEFORE
335 ; CHECK-NOT: NOT
336 ; CHECK-DAG: AFTER
337 This case will reject input strings where BEFORE occurs after AFTER.
339 With captured variables, CHECK-DAG: is able to match valid topological
341 orderings of a DAG with edges from the definition of a variable to its
342 use. It's useful, e.g., when your test cases need to match different
343 output sequences from the instruction scheduler. For example,
344 ; CHECK-DAG: add [[REG1:r[0-9]+]], r1, r2
346 ; CHECK-DAG: add [[REG2:r[0-9]+]], r3, r4
347 ; CHECK: mul r5, [[REG1]], [[REG2]]
348 In this case, any order of that two add instructions will be allowed.
350 If you are defining and using variables in the same CHECK-DAG: block,
352 be aware that the definition rule can match after its use.
353 So, for instance, the code below will pass:
355 ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
357 ; CHECK-DAG: vmov.32 [[REG2]][1]
358 vmov.32 d0[1]
359 vmov.32 d0[0]
360 While this other code, will not:
362 ; CHECK-DAG: vmov.32 [[REG2:d[0-9]+]][0]
364 ; CHECK-DAG: vmov.32 [[REG2]][1]
365 vmov.32 d1[1]
366 vmov.32 d0[0]
367 While this can be very useful, it's also dangerous, because in the case
369 of register sequence, you must have a strong order (read before write,
370 copy before use, etc). If the definition your test is looking for
371 doesn't match (because of a bug in the compiler), it may match further
372 away from the use, and mask real bugs away.
373 In those cases, to enforce the order, use a non-DAG directive between
375 DAG-blocks.
376 A CHECK-DAG: directive skips matches that overlap the matches of any
378 preceding CHECK-DAG: directives in the same CHECK-DAG: block. Not only
379 is this non-overlapping behavior consistent with other directives, but
380 it's also necessary to handle sets of non-unique strings or patterns.
381 For example, the following directives look for unordered log entries
382 for two tasks in a parallel program, such as the OpenMP runtime:
383 // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin
385 // CHECK-DAG: [[THREAD_ID]]: task_end
386 //
387 // CHECK-DAG: [[THREAD_ID:[0-9]+]]: task_begin
388 // CHECK-DAG: [[THREAD_ID]]: task_end
389 The second pair of directives is guaranteed not to match the same log
391 entries as the first pair even though the patterns are identical and
392 even if the text of the log entries is identical because the thread ID
393 manages to be reused.
394 The CHECK-LABEL: directive
396 Sometimes in a file containing multiple tests divided into logical
397 blocks, one or more CHECK: directives may inadvertently succeed by
398 matching lines in a later block. While an error will usually eventually
399 be generated, the check flagged as causing the error may not actually
400 bear any relationship to the actual source of the problem.
401 In order to produce better error messages in these cases, the
403 "CHECK-LABEL:" directive can be used. It is treated identically to a
404 normal CHECK directive except that FileCheck makes an additional as‐
405 sumption that a line matched by the directive cannot also be matched by
406 any other check present in match-filename; this is intended to be used
407 for lines containing labels or other unique identifiers. Conceptually,
408 the presence of CHECK-LABEL divides the input stream into separate
409 blocks, each of which is processed independently, preventing a CHECK:
410 directive in one block matching a line in another block. If --en‐
411 able-var-scope is in effect, all local variables are cleared at the be‐
412 ginning of the block.
413 For example,
415 define %struct.C* @C_ctor_base(%struct.C* %this, i32 %x) {
417 entry:
418 ; CHECK-LABEL: C_ctor_base:
419 ; CHECK: mov [[SAVETHIS:r[0-9]+]], r0
420 ; CHECK: bl A_ctor_base
421 ; CHECK: mov r0, [[SAVETHIS]]
422 %0 = bitcast %struct.C* %this to %struct.A*
423 %call = tail call %struct.A* @A_ctor_base(%struct.A* %0)
424 %1 = bitcast %struct.C* %this to %struct.B*
425 %call2 = tail call %struct.B* @B_ctor_base(%struct.B* %1, i32 %x)
426 ret %struct.C* %this
427 }
428 define %struct.D* @D_ctor_base(%struct.D* %this, i32 %x) {
430 entry:
431 ; CHECK-LABEL: D_ctor_base:
432 The use of CHECK-LABEL: directives in this case ensures that the three
434 CHECK: directives only accept lines corresponding to the body of the
435 @C_ctor_base function, even if the patterns match lines found later in
436 the file. Furthermore, if one of these three CHECK: directives fail,
437 FileCheck will recover by continuing to the next block, allowing multi‐
438 ple test failures to be detected in a single invocation.
439 There is no requirement that CHECK-LABEL: directives contain strings
441 that correspond to actual syntactic labels in a source or output lan‐
442 guage: they must simply uniquely match a single line in the file being
443 verified.
444 CHECK-LABEL: directives cannot contain variable definitions or uses.
446 FileCheck Regex Matching Syntax
448 All FileCheck directives take a pattern to match. For most uses of
449 FileCheck, fixed string matching is perfectly sufficient. For some
450 things, a more flexible form of matching is desired. To support this,
451 FileCheck allows you to specify regular expressions in matching
452 strings, surrounded by double braces: {{yourregex}}. FileCheck imple‐
453 ments a POSIX regular expression matcher; it supports Extended POSIX
454 regular expressions (ERE). Because we want to use fixed string matching
455 for a majority of what we do, FileCheck has been designed to support
456 mixing and matching fixed string matching with regular expressions.
457 This allows you to write things like this:
458 ; CHECK: movhpd {{[0-9]+}}(%esp), {{%xmm[0-7]}}
460 In this case, any offset from the ESP register will be allowed, and any
462 xmm register will be allowed.
463 Because regular expressions are enclosed with double braces, they are
465 visually distinct, and you don't need to use escape characters within
466 the double braces like you would in C. In the rare case that you want
467 to match double braces explicitly from the input, you can use something
468 ugly like {{[}][}]}} as your pattern. Or if you are using the repeti‐
469 tion count syntax, for example [[:xdigit:]]{8} to match exactly 8 hex
470 digits, you would need to add parentheses like this
471 {{([[:xdigit:]]{8})}} to avoid confusion with FileCheck's closing dou‐
472 ble-brace.
473 FileCheck String Substitution Blocks
475 It is often useful to match a pattern and then verify that it occurs
476 again later in the file. For codegen tests, this can be useful to al‐
477 low any register, but verify that that register is used consistently
478 later. To do this, FileCheck supports string substitution blocks that
479 allow string variables to be defined and substituted into patterns.
480 Here is a simple example:
481 ; CHECK: test5:
483 ; CHECK: notw [[REGISTER:%[a-z]+]]
484 ; CHECK: andw {{.*}}[[REGISTER]]
485 The first check line matches a regex %[a-z]+ and captures it into the
487 string variable REGISTER. The second line verifies that whatever is in
488 REGISTER occurs later in the file after an "andw". FileCheck string
489 substitution blocks are always contained in [[ ]] pairs, and string
490 variable names can be formed with the regex [a-zA-Z_][a-zA-Z0-9_]*. If
491 a colon follows the name, then it is a definition of the variable; oth‐
492 erwise, it is a substitution.
493 FileCheck variables can be defined multiple times, and substitutions
495 always get the latest value. Variables can also be substituted later
496 on the same line they were defined on. For example:
497 ; CHECK: op [[REG:r[0-9]+]], [[REG]]
499 Can be useful if you want the operands of op to be the same register,
501 and don't care exactly which register it is.
502 If --enable-var-scope is in effect, variables with names that start
504 with $ are considered to be global. All others variables are local.
505 All local variables get undefined at the beginning of each CHECK-LABEL
506 block. Global variables are not affected by CHECK-LABEL. This makes it
507 easier to ensure that individual tests are not affected by variables
508 set in preceding tests.
509 FileCheck Numeric Substitution Blocks
511 FileCheck also supports numeric substitution blocks that allow defining
512 numeric variables and checking for numeric values that satisfy a nu‐
513 meric expression constraint based on those variables via a numeric sub‐
514 stitution. This allows CHECK: directives to verify a numeric relation
515 between two numbers, such as the need for consecutive registers to be
516 used.
517 The syntax to define a numeric variable is [[#<NUMVAR>:]] where <NUM‐
519 VAR> is the name of the numeric variable to define to the matching
520 value.
521 For example:
523 ; CHECK: mov r[[#REG:]], 42
525 would match mov r5, 42 and set REG to the value 5.
527 The syntax of a numeric substitution is [[#<expr>]] where <expr> is an
529 expression. An expression is recursively defined as:
530 • a numeric operand, or
532 • an expression followed by an operator and a numeric operand.
534 A numeric operand is a previously defined numeric variable, or an inte‐
536 ger literal. The supported operators are + and -. Spaces are accepted
537 before, after and between any of these elements.
538 For example:
540 ; CHECK: load r[[#REG:]], [r0]
542 ; CHECK: load r[[#REG+1]], [r1]
543 The above example would match the text:
545 load r5, [r0]
547 load r6, [r1]
548 but would not match the text:
550 load r5, [r0]
552 load r7, [r1]
553 due to 7 being unequal to 5 + 1.
555 The syntax also supports an empty expression, equivalent to writing
557 {{[0-9]+}}, for cases where the input must contain a numeric value but
558 the value itself does not matter:
559 ; CHECK-NOT: mov r0, r[[#]]
561 to check that a value is synthesized rather than moved around.
563 A numeric variable can also be defined to the result of a numeric ex‐
565 pression, in which case the numeric expression is checked and if veri‐
566 fied the variable is assigned to the value. The unified syntax for both
567 defining numeric variables and checking a numeric expression is thus
568 [[#<NUMVAR>: <expr>]] with each element as described previously.
569 The --enable-var-scope option has the same effect on numeric variables
571 as on string variables.
572 Important note: In its current implementation, an expression cannot use
574 a numeric variable defined earlier in the same CHECK directive.
575 FileCheck Pseudo Numeric Variables
577 Sometimes there's a need to verify output that contains line numbers of
578 the match file, e.g. when testing compiler diagnostics. This intro‐
579 duces a certain fragility of the match file structure, as "CHECK:"
580 lines contain absolute line numbers in the same file, which have to be
581 updated whenever line numbers change due to text addition or deletion.
582 To support this case, FileCheck expressions understand the @LINE pseudo
584 numeric variable which evaluates to the line number of the CHECK pat‐
585 tern where it is found.
586 This way match patterns can be put near the relevant test lines and in‐
588 clude relative line number references, for example:
589 // CHECK: test.cpp:[[# @LINE + 4]]:6: error: expected ';' after top level declarator
591 // CHECK-NEXT: {{^int a}}
592 // CHECK-NEXT: {{^ \^}}
593 // CHECK-NEXT: {{^ ;}}
594 int a
595 To support legacy uses of @LINE as a special string variable, FileCheck
597 also accepts the following uses of @LINE with string substitution block
598 syntax: [[@LINE]], [[@LINE+<offset>]] and [[@LINE-<offset>]] without
599 any spaces inside the brackets and where offset is an integer.
600 Matching Newline Characters
602 To match newline characters in regular expressions the character class
603 [[:space:]] can be used. For example, the following pattern:
604 // CHECK: DW_AT_location [DW_FORM_sec_offset] ([[DLOC:0x[0-9a-f]+]]){{[[:space:]].*}}"intd"
606 matches output of the form (from llvm-dwarfdump):
608 DW_AT_location [DW_FORM_sec_offset] (0x00000233)
610 DW_AT_name [DW_FORM_strp] ( .debug_str[0x000000c9] = "intd")
611 letting us set the FileCheck variable DLOC to the desired value
613 0x00000233, extracted from the line immediately preceding "intd".
614
616 Maintained by the LLVM Team (https://llvm.org/).
617
619 2003-2021, LLVM Project
62010 2021-04-19 FILECHECK(1)