Change filecheck default to dump input on failure

[mehdi_amini]

Summary

Having the input dumped on failure seems like a better
default: I debugged FileCheck tests for a while without knowing
about this option, which really helps to understand failures.

Remove -dump-input-on-failure and the environment variable
FILECHECK_DUMP_INPUT_ON_FAILURE which are now obsolete.

[probinson]

I don't remember the exact reasoning but I believe it had something to do with bot logs? @jdenny or @thopre might remember.

[mehdi_amini]

Update tests

[aartbik]

Yes, assuming nobody remembers an adverse side-effect, I think this change will help debugging future failures.

[mehdi_amini]

In D81422#2080758, @probinson wrote:

I don't remember the exact reasoning but I believe it had something to do with bot logs? @jdenny or @thopre might remember.

It'd be interesting to hear about it: having the bot log including the input on failure could indeed help debugging when something fails in flaky way, or is dependent on the environment (like the path where the code is checked out, etc.).
At least in the past it could have saved me trouble when only a single bot was failing in mysterious way and the bot owner had to be involved to help figure out.

(also right now we're inconsistent: many tests are adding the flag explicitly)

[eugenis]

This would help debugging sanitizer failures on the bots a lot.

[jpienaar]

I think this is a good default given it provides very useful info in failure case. For cases where folks expect it to fail + don't want it logged, then setting never (if that is a concern) seems better behavior IMHO.

[thopre]

In D81422#2080758, @probinson wrote:

I don't remember the exact reasoning but I believe it had something to do with bot logs? @jdenny or @thopre might remember.

I guess -dump-input just followed the existing default behavior when -dump-input-on-failure was introduced. There was several mentions of whether to make it the default when that was introduced [1][2] and my understanding was the worry was on whether it would make some FileCheck test fail. I think with FileCheckOpt this is no longer a concern. I would have personally benefited from having this the default so I support this change.

[1] https://reviews.llvm.org/D49328?id=155527#inline-433596
[2] https://reviews.llvm.org/D49328#1170186

[jdenny]

In D81422#2080861, @mehdi_amini wrote:

In D81422#2080758, @probinson wrote:

I don't remember the exact reasoning but I believe it had something to do with bot logs? @jdenny or @thopre might remember.

The only problem I've seen is the extreme verbosity when there are many failures. For example, I have experienced cases where that verbosity hung an IDE that was collecting the output. But if people have problems, they can set FILECHECK_OPTS=-dump-input=never, so it's probably fine.

It'd be interesting to hear about it: having the bot log including the input on failure could indeed help debugging when something fails in flaky way, or is dependent on the environment (like the path where the code is checked out, etc.).
At least in the past it could have saved me trouble when only a single bot was failing in mysterious way and the bot owner had to be involved to help figure out.

(also right now we're inconsistent: many tests are adding the flag explicitly)

I imagined more and more bots would set this eventually via FILECHECK_OPTS. Changing the default seems fine too.

llvm/test/FileCheck/dump-input-enable.txt

78

Are the tests in this section passing for you now that the default is fail?

126–127

The preceding section checks -dump-input=fail, so you can probably just remove this -dump-input-on-failure section.

127

Why is -dump-input=never needed here?

[jdenny]

Also, please grep for FILECHECK_DUMP_INPUT_ON_FAILURE. There are a few more occurrences to remove from the repo.

[jdenny]

llvm/utils/FileCheck/FileCheck.cpp

117

Please mention in the patch summary that -dump-input-on-failure and FILECHECK_DUMP_INPUT_ON_FAILURE are being dropped.

[mehdi_amini]

Fix more tests

[mehdi_amini]

llvm/test/FileCheck/dump-input-enable.txt

78

Now they do :)
I originally pushed to Phab to get the pre-merge testing running while I was still fixing a few things locally, I didn't expect such fast reviews!
Should be all good now.

[jdenny]

llvm/test/FileCheck/dump-input-enable.txt

77

The previous section already covers -dump-input=never. This section was covering the case where -dump-input isn't specified. Maybe you should just update it to check that the default is now fail instead of never.

llvm/test/FileCheck/lit.local.cfg

42

Please add -dump-input=never to this first FileCheck call. Otherwise, the example is broken because FileCheck never prints expected string found in input when -dump-input=fail regardless of -v.

llvm/utils/FileCheck/FileCheck.cpp

117

This is marked as done, but I don't see the change.

[jdenny]

By the way, -vv combined with -dump-input=fail provides a lot of additional information that can be helpful when debugging. Bots could pass that via FILECHECK_OPTS, or it could become the default when -dump-input is not never. In the latter case, I suggest a separate patch to make the review easier. What do people think?

[mehdi_amini]

Address @jdenny's comments:

• fix the example in lit.local.cfg
• Test the default value for dump-input

llvm/test/FileCheck/lit.local.cfg

42

Well spotted!

llvm/utils/FileCheck/FileCheck.cpp

117

That's because I amended my commit locally but arc does not propagate the update to Phabricator apparently: https://phabricator.kde.org/T7711 ; I'll do it manually

[jdenny]

LGTM. Thanks!

[arsenm]

I think this is a worse default for development for large tests. For some generated check lines, I'm seeing many thousand of line dumps on failure, which just makes it harder to see the point it actually failed at. Can we move this default into the buildbot defaults or something so the log is clearer when a handful of tests fails? When working on patches, there are often a larger number of failures

[mehdi_amini]

In D81422#2083761, @arsenm wrote:

I think this is a worse default for development for large tests.

Maybe the issue is with large tests that needs to be broken up?
To me this is a general improvement during development at my desk and reading a test output to understand the failure: this goes beyond build bots.

(you have the environment variable you can set locally if you don't want the behavior though)

[arsenm]

In D81422#2083808, @mehdi_amini wrote:

In D81422#2083761, @arsenm wrote:

I think this is a worse default for development for large tests.

Maybe the issue is with large tests that needs to be broken up?

This isn't really manageable, especially with the trend of using update_* test checks scripts. Stuff like legalization tests just have to stress every combination of inputs. The -dump-input-on-failure could also be smarter about how much context it prints

To me this is a general improvement during development at my desk and reading a test output to understand the failure: this goes beyond build bots.

(you have the environment variable you can set locally if you don't want the behavior though)

The environment variable was removed though? I would also at least expect this to be an option I can set at cmake time and never have to think about again

[jdenny]

In D81422#2083882, @arsenm wrote:

The environment variable was removed though? I would also at least expect this to be an option I can set at cmake time and never have to think about again

Could you set FILECHECK_OPTS=-dump-input=never in your ~/.profile?

[mehdi_amini]

In D81422#2083882, @arsenm wrote:

In D81422#2083808, @mehdi_amini wrote:

In D81422#2083761, @arsenm wrote:

I think this is a worse default for development for large tests.

Maybe the issue is with large tests that needs to be broken up?

This isn't really manageable, especially with the trend of using update_* test checks scripts. Stuff like legalization tests just have to stress every combination of inputs.

This is something that the script generating every combination could manage to split as well?
Alternatively, can these very large test be appended --dump-input=never on the RUN line? (maybe the test generator can do this?)

[mehdi_amini]

I'm thinking about a possible improvement here: we could have FileCheck dump the input for the current CHECK-LABEL section only: it seems like it could reduce the output drastically while still preserving how useful the information is?

[arsenm]

In D81422#2090425, @mehdi_amini wrote:

I'm thinking about a possible improvement here: we could have FileCheck dump the input for the current CHECK-LABEL section only: it seems like it could reduce the output drastically while still preserving how useful the information is?

That would help some. In my situation I've been making a lot of changes that touch dozens of generated MIR tests, and change most of the functions. If the dump constrained itself to just the first -LABEL section it would be more manageable

[jdenny]

In D81422#2090425, @mehdi_amini wrote:

I'm thinking about a possible improvement here: we could have FileCheck dump the input for the current CHECK-LABEL section only: it seems like it could reduce the output drastically while still preserving how useful the information is?

One FileCheck invocation can report multiple errors, one per CHECK-LABEL section, and I prefer to see all errors every time.

I also prefer to see the entire input dump (with annotations produced by -vv) as sometimes the error FileCheck reports is far away from the actual error. For example, maybe the CHECK-LABEL directives matched text at unexpected locations in the input, and then the directives in their sections failed as a result. It might be hard to determine that the CHECK-LABEL directives were at fault without seeing the text it should have matched outside of its (incorrect) section.

If you choose to limit the dump to one CHECK-LABEL section, please make that behavior optional via a command-line option (which can be set via FILECHECK_OPTS).

[mehdi_amini]

In D81422#2090618, @jdenny wrote:

In D81422#2090425, @mehdi_amini wrote:

I'm thinking about a possible improvement here: we could have FileCheck dump the input for the current CHECK-LABEL section only: it seems like it could reduce the output drastically while still preserving how useful the information is?

One FileCheck invocation can report multiple errors, one per CHECK-LABEL section, and I prefer to see all errors every time.

Yeah I had in mind to show all the errors for the current section, then the input for the section, before moving to the next section.

I also prefer to see the entire input dump (with annotations produced by -vv) as sometimes the error FileCheck reports is far away from the actual error. For example, maybe the CHECK-LABEL directives matched text at unexpected locations in the input, and then the directives in their sections failed as a result. It might be hard to determine that the CHECK-LABEL directives were at fault without seeing the text it should have matched outside of its (incorrect) section.

Sure: but that seems like not the most common case to me: if we start by showing the section we matched it provides already a pretty good indication.

If you choose to limit the dump to one CHECK-LABEL section, please make that behavior optional via a command-line option (which can be set via FILECHECK_OPTS).

I thought it would be a better default actually, leaving the full-full as opt-in

[jdenny]

In D81422#2090725, @mehdi_amini wrote:

In D81422#2090618, @jdenny wrote:

In D81422#2090425, @mehdi_amini wrote:

I'm thinking about a possible improvement here: we could have FileCheck dump the input for the current CHECK-LABEL section only: it seems like it could reduce the output drastically while still preserving how useful the information is?

One FileCheck invocation can report multiple errors, one per CHECK-LABEL section, and I prefer to see all errors every time.

Yeah I had in mind to show all the errors for the current section, then the input for the section, before moving to the next section.

I'm not sure I understand. Currently, (1) FileCheck prints all errors up front in case that's sufficient without the dump, and then (2) FileCheck prints the dump with annotations showing the errors again (and successful directives, including labels, if -vv). Are you talking about interleaving 1 and 2? Does that actually make it easier to read? Maybe just omit lines from the dump instead?

I also prefer to see the entire input dump (with annotations produced by -vv) as sometimes the error FileCheck reports is far away from the actual error. For example, maybe the CHECK-LABEL directives matched text at unexpected locations in the input, and then the directives in their sections failed as a result. It might be hard to determine that the CHECK-LABEL directives were at fault without seeing the text it should have matched outside of its (incorrect) section.

Sure: but that seems like not the most common case to me: if we start by showing the section we matched it provides already a pretty good indication.

If you choose to limit the dump to one CHECK-LABEL section, please make that behavior optional via a command-line option (which can be set via FILECHECK_OPTS).

I thought it would be a better default actually, leaving the full-full as opt-in

I'm not sure how common it is, and I don't know what the default should be. From the command line, I can always run again with different options to get missing info. From the bots, it's harder to get missing info (which is why I suggested -vv for the bots).

[arsenm]

I'm growing to dislike the new behavior even more as I use it. I don't think restricting the dump to CHECK-LABEL prefixes will even help. The amount of context printed previously was good enough for development use. If I ever can't figure it out from the diff, I want to look at the output completely separate from the terminal. This is adding a lot of noise that doesn't help show me the failure point, and often fills my terminal scrollback buffer.

For AMDGPU test cases for example, every function has a long chunk of metadata that is irrelevant to the majority of tests. This floods my terminal even if a single function failed between check labels. I think this should revert to the old behavior. I think dump full on input would only be a reasonable default on build bots (where even then it might need some restrictions to avoid gigantic build logs if a really broken patch were committed).

[aeubanks]

FWIW I didn't see this change initially but was pleasantly surprised with the extra output when debugging a newly added (relatively small) test.

[jdenny]

Perhaps llvm-dev is the right place to discuss the default behavior.

Regardless of that default, perhaps there should be an option that limits the dump to N lines that always encloses the first error.

[mehdi_amini]

In D81422#2093360, @arsenm wrote:

The amount of context printed previously was good enough for development use. If I ever can't figure it out from the diff, I want to look at the output completely separate from the terminal.

I have the totally opposite experience: I can't do any debugging efficiently without this option. Empirically, most new-comers to writing tests with FileCheck (in MLIR, TensorFlow, XLA, IREE, etc.) have been manually adding -dump-input-on-failure hard-coded into the test themselves, which is a pretty good indication.

Having something contextual with some limited scope around the failures would work for me as well (the previous situation was just not usable for me however)

[arsenm]

I would also expect a simple command line flag to llvm-lit to be able to control this, rather than having to set an environment variable

mlir/test/mlir-tblgen/op-format-spec.td

1

All of these MLIR tests are microscopic and I don't think this is a representative sample across all the projects. Most testcases are significantly larger, and have hundreds if not thousands of lines of output

[mehdi_amini]

In D81422#2096643, @arsenm wrote:

I would also expect a simple command line flag to llvm-lit to be able to control this, rather than having to set an environment variable

Would you like a lit command line flag that set the environment variable? I think that's easily doable

mlir/test/mlir-tblgen/op-format-spec.td

1

Well, if this can act as an extra incentive to break-up such large tests, it see it as a win: debugging failing patterns in the middle of such a large test output is not nice regardless.

clang/test/CodeGenObjC/externally-retained.m

-// RUN: %clang_cc1 -triple x86_64-apple-macosx10.13.0 -fobjc-arc -fblocks -Wno-objc-root-class -O0 %s -S -emit-llvm -o - | FileCheck %s --dump-input-on-failure
-// RUN: %clang_cc1 -triple x86_64-apple-macosx10.13.0 -fobjc-arc -fblocks -Wno-objc-root-class -O0 -xobjective-c++ -std=c++11 %s -S -emit-llvm -o - | FileCheck %s --check-prefix CHECKXX --dump-input-on-failure
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.13.0 -fobjc-arc -fblocks -Wno-objc-root-class -O0 %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.13.0 -fobjc-arc -fblocks -Wno-objc-root-class -O0 -xobjective-c++ -std=c++11 %s -S -emit-llvm -o - | FileCheck %s --check-prefix CHECKXX
 
 #define EXT_RET __attribute__((objc_externally_retained))
 
 @interface ObjTy @end
 
 ObjTy *global;
 
 #if __cplusplus

clang/test/Driver/rocm-device-libs.cl

 // REQUIRES: clang-driver
 // REQUIRES: amdgpu-registered-target
 // REQUIRES: !system-windows
 
 // Test flush-denormals-to-zero enabled uses oclc_daz_opt_on
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx900 \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
 
 
 
 // Make sure the different denormal default is respected for gfx8
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx803 \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DEFAULT,GFX803-DEFAULT,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DEFAULT,GFX803-DEFAULT,GFX803,WAVE64 %s
 
 
 
 // Make sure the non-canonical name works
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=fiji \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DEFAULT,GFX803-DEFAULT,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DEFAULT,GFX803-DEFAULT,GFX803,WAVE64 %s
 
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx900 \
 // RUN:   -cl-denorms-are-zero \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DAZ,GFX900,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DAZ,GFX900,WAVE64 %s
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx803 \
 // RUN:   -cl-denorms-are-zero \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DAZ,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DAZ,GFX803,WAVE64 %s
 
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx803 \
 // RUN:   -cl-finite-math-only \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-FINITE-ONLY,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-FINITE-ONLY,GFX803,WAVE64 %s
 
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx803                     \
 // RUN:   -cl-fp32-correctly-rounded-divide-sqrt \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-CORRECT-SQRT,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-CORRECT-SQRT,GFX803,WAVE64 %s
 
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx803                     \
 // RUN:   -cl-fast-relaxed-math \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-FAST-RELAXED,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-FAST-RELAXED,GFX803,WAVE64 %s
 
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx803                     \
 // RUN:   -cl-unsafe-math-optimizations \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-UNSAFE,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-UNSAFE,GFX803,WAVE64 %s
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx1010                    \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX1010,WAVE32 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX1010,WAVE32 %s
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx1011                    \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX1011,WAVE32 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX1011,WAVE32 %s
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx1012                    \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX1012,WAVE32 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX1012,WAVE32 %s
 
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx1010 -mwavefrontsize64  \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX1010,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX1010,WAVE64 %s
 
 // RUN: %clang -### -target amdgcn-amd-amdhsa    \
 // RUN:   -x cl -mcpu=gfx1010 -mwavefrontsize64 -mno-wavefrontsize64  \
 // RUN:   --rocm-path=%S/Inputs/rocm \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX1010,WAVE32 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX1010,WAVE32 %s
 
 // Ignore -mno-wavefrontsize64 without wave32 support
 // RUN: %clang -### -target amdgcn-amd-amdhsa       \
 // RUN:   -x cl -mcpu=gfx803  -mno-wavefrontsize64  \
 // RUN:   --rocm-path=%S/Inputs/rocm    \
 // RUN:   %s \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMMON,GFX803,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMMON,GFX803,WAVE64 %s
 
 
 
 // Test --hip-device-lib-path format
 // RUN: %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx900 \
 // RUN:   --hip-device-lib-path=%S/Inputs/rocm/amdgcn/bitcode \
 // RUN:   %S/opencl.cl \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
 
 // Test environment variable HIP_DEVICE_LIB_PATH
 // RUN: env HIP_DEVICE_LIB_PATH=%S/Inputs/rocm/amdgcn/bitcode %clang -### -target amdgcn-amd-amdhsa \
 // RUN:   -x cl -mcpu=gfx900 \
 // RUN:   %S/opencl.cl \
-// RUN: 2>&1 | FileCheck -dump-input-on-failure --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
+// RUN: 2>&1 | FileCheck  --check-prefixes=COMMON,COMMON-DEFAULT,GFX900-DEFAULT,GFX900,WAVE64 %s
 
 
 
 // COMMON: "-triple" "amdgcn-amd-amdhsa"
 // COMMON-SAME: "-mlink-builtin-bitcode" "{{.*}}/amdgcn/bitcode/opencl.bc"
 // COMMON-SAME: "-mlink-builtin-bitcode" "{{.*}}/amdgcn/bitcode/ocml.bc"
 // COMMON-SAME: "-mlink-builtin-bitcode" "{{.*}}/amdgcn/bitcode/ockl.bc"
 

compiler-rt/test/fuzzer/fork.test

 
 # access-violation is the error thrown on Windows. Address will be smaller on i386.
 CRASH: {{SEGV|access-violation}} on unknown address 0x00000000
 RUN: %cpp_compiler %S/ShallowOOMDeepCrash.cpp -o %t-ShallowOOMDeepCrash
 RUN: not %run %t-ShallowOOMDeepCrash -fork=1 -rss_limit_mb=128 2>&1 | FileCheck %s --check-prefix=CRASH
 
 MAX_TOTAL_TIME: INFO: fuzzed for {{.*}} seconds, wrapping up soon
 MAX_TOTAL_TIME: INFO: exiting: {{.*}} time:
-RUN: not %run %t-ShallowOOMDeepCrash -fork=1 -rss_limit_mb=128 -ignore_crashes=1 -max_total_time=10 2>&1 | FileCheck %s --dump-input-on-failure --check-prefix=MAX_TOTAL_TIME
+RUN: not %run %t-ShallowOOMDeepCrash -fork=1 -rss_limit_mb=128 -ignore_crashes=1 -max_total_time=10 2>&1 | FileCheck %s  --check-prefix=MAX_TOTAL_TIME

debuginfo-tests/llvm-prettyprinters/gdb/llvm-support.gdb

-# RUN: gdb -q -batch -n -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' -x %s %llvm_tools_dir/check-gdb-llvm-support | FileCheck %s --dump-input-on-failure
+# RUN: gdb -q -batch -n -iex 'source %llvm_src_root/utils/gdb-scripts/prettyprinters.py' -x %s %llvm_tools_dir/check-gdb-llvm-support | FileCheck %s
 # REQUIRES: debug-info
 
 break main
 run
 
 # CHECK: llvm::ArrayRef of length 3 = {1, 2, 3}
 p ArrayRef
 

llvm/docs/CommandGuide/FileCheck.rst

.. option:: --implicit-check-not check-pattern
   For example, "``--implicit-check-not warning:``" can be useful when testing
   diagnostic messages from tools that don't have an option similar to ``clang
   -verify``. With this option FileCheck will verify that input does not contain
   warnings not covered by any ``CHECK:`` patterns.
 
 .. option:: --dump-input <mode>
 
   Dump input to stderr, adding annotations representing currently enabled
-  diagnostics.  Do this either 'always', on 'fail', or 'never'.  Specify 'help'
-  to explain the dump format and quit.
-
-.. option:: --dump-input-on-failure
-
-  When the check fails, dump all of the original input.  This option is
-  deprecated in favor of `--dump-input=fail`.
+  diagnostics.  Do this either 'always', on 'fail' (default), or 'never'.
+  Specify 'help' to explain the dump format and quit.
 
 .. option:: --enable-var-scope
 
   Enables scope for regex variables.
 
   Variables with names that start with ``$`` are considered global and
   remain set throughout the file.
 

llvm/test/CodeGen/AArch64/speculation-hardening-dagisel.ll

-; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,SLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,NOSLH --dump-input-on-failure
+; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,SLH
+; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,NOSLH
 
 declare i64 @g(i64, i64) local_unnamed_addr
 define i64 @f_using_reserved_reg_x16(i64 %a, i64 %b) local_unnamed_addr SLHATTR {
 ; CHECK-LABEL: f_using_reserved_reg_x16
 ; SLH: dsb sy
 ; SLH: isb
 ; NOSLH-NOT: dsb sy
 ; NOSLH-NOT: isb

llvm/test/CodeGen/AArch64/speculation-hardening-loads.ll

-; RUN: llc < %s -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --dump-input-on-failure
+; RUN: llc < %s -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s
 
 define i128 @ldp_single_csdb(i128* %p) speculative_load_hardening {
 entry:
   %0 = load i128, i128* %p, align 16
   ret i128 %0
 ; CHECK-LABEL: ldp_single_csdb
 ; CHECK:      ldp   x8, x1, [x0]
 ; CHECK-NEXT: cmp sp, #0

llvm/test/CodeGen/AArch64/speculation-hardening.ll

-; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,SLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,NOSLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -global-isel | FileCheck %s --check-prefixes=CHECK,SLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -global-isel | FileCheck %s --check-prefixes=CHECK,NOSLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -fast-isel | FileCheck %s --check-prefixes=CHECK,SLH --dump-input-on-failure
-; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -fast-isel | FileCheck %s --check-prefixes=CHECK,NOSLH --dump-input-on-failure
+; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,SLH
+; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu | FileCheck %s --check-prefixes=CHECK,NOSLH
+; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -global-isel | FileCheck %s --check-prefixes=CHECK,SLH
+; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -global-isel | FileCheck %s --check-prefixes=CHECK,NOSLH
+; RUN: sed -e 's/SLHATTR/speculative_load_hardening/' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -fast-isel | FileCheck %s --check-prefixes=CHECK,SLH
+; RUN: sed -e 's/SLHATTR//' %s | llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -fast-isel | FileCheck %s --check-prefixes=CHECK,NOSLH
 
 define i32 @f(i8* nocapture readonly %p, i32 %i, i32 %N) local_unnamed_addr SLHATTR {
 ; CHECK-LABEL: f
 entry:
 ; SLH:  cmp sp, #0
 ; SLH:  csetm x16, ne
 ; NOSLH-NOT:  cmp sp, #0
 ; NOSLH-NOT:  csetm x16, ne

llvm/test/CodeGen/AArch64/speculation-hardening.mir

 # RUN: llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu \
 # RUN:     -start-before aarch64-speculation-hardening -o - %s \
-# RUN:   | FileCheck %s --dump-input-on-failure
+# RUN:   | FileCheck %s
 
 # Check that the speculation hardening pass generates code as expected for
 # basic blocks ending with a variety of branch patterns:
 # - (1) no branches (fallthrough)
 # - (2) one unconditional branch
 # - (3) one conditional branch + fall-through
 # - (4) one conditional branch + one unconditional branch
 # - other direct branches don't seem to be generated by the AArch64 codegen

llvm/test/FileCheck/comment/after-words.txt

 # Comment prefixes are not recognized at ends of words.
 
 RUN: echo 'foo'                 >  %t.in
 RUN: echo 'bar'                 >> %t.in
 RUN: echo 'foo'                 >> %t.in
 RUN: echo 'bar'                 >> %t.in
 RUN: echo 'FOO-COM: CHECK: foo' >  %t.chk
 RUN: echo 'RUN_COM: CHECK: bar' >> %t.chk
 RUN: echo 'RUN3COM: CHECK: foo' >> %t.chk
 RUN: echo ' COMRUN: CHECK: bar' >> %t.chk
-RUN: %ProtectFileCheckOutput FileCheck -vv %t.chk < %t.in 2>&1 | FileCheck %s
+RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 | FileCheck %s
 
 CHECK: .chk:1:17: remark: CHECK: expected string found in input
 CHECK: .chk:2:17: remark: CHECK: expected string found in input
 CHECK: .chk:3:17: remark: CHECK: expected string found in input
 CHECK: .chk:4:17: remark: CHECK: expected string found in input

llvm/test/FileCheck/comment/blank-comments.txt

 # Comment directives with blank contents are fine.
 
 RUN: echo 'foo'        >  %t.in
 RUN: echo 'COM:'       >  %t.chk
 RUN: echo 'CHECK: foo' >> %t.chk
 RUN: echo ' COM: '     >> %t.chk
-RUN: %ProtectFileCheckOutput FileCheck -vv %t.chk < %t.in 2>&1 | FileCheck %s
+RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 | FileCheck %s
 
 CHECK: .chk:2:8: remark: CHECK: expected string found in input

llvm/test/FileCheck/comment/suffixes.txt

 # Comment prefixes plus check directive suffixes are not comment directives
 # and are treated as plain text.
 
 RUN: echo foo                    >  %t.in
 RUN: echo bar                    >> %t.in
 RUN: echo 'COM-NEXT: CHECK: foo' >  %t.chk
 RUN: echo 'RUN-NOT: CHECK: bar'  >> %t.chk
 
-RUN: %ProtectFileCheckOutput FileCheck -vv %t.chk < %t.in 2>&1 | \
+RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 | \
 RUN:   FileCheck -check-prefix=CHECK1 %s
 
 CHECK1: .chk:1:18: remark: CHECK: expected string found in input
 CHECK1: .chk:2:17: remark: CHECK: expected string found in input
 
 # But we can define them as comment prefixes.
 
 RUN: %ProtectFileCheckOutput \
-RUN: FileCheck -vv -comment-prefixes=COM,RUN,RUN-NOT %t.chk < %t.in 2>&1 | \
+RUN: FileCheck -dump-input=never -vv -comment-prefixes=COM,RUN,RUN-NOT %t.chk < %t.in 2>&1 | \
 RUN:   FileCheck -check-prefix=CHECK2 %s
 
 CHECK2: .chk:1:18: remark: CHECK: expected string found in input
 CHECK2-NOT: .chk:2

llvm/test/FileCheck/comment/suppresses-checks.txt

 # Comment directives successfully comment out check directives.
 
 # Check all default comment prefixes.
 # Check that a comment directive at the beginning/end of the file is handled.
 # Check that the preceding/following line's check directive is not affected.
 RUN: echo 'foo'                    >  %t-1.in
 RUN: echo 'COM: CHECK: bar'        >  %t-1.chk
 RUN: echo 'CHECK: foo'             >> %t-1.chk
 RUN: echo 'RUN: echo "CHECK: baz"' >> %t-1.chk
-RUN: %ProtectFileCheckOutput FileCheck -vv %t-1.chk < %t-1.in 2>&1 | \
+RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -vv %t-1.chk < %t-1.in 2>&1 | \
 RUN:   FileCheck -DCHECK_LINE=2 %s
 
 # Check the case of one user-specified comment prefix.
 # Check that a comment directive not at the beginning of a line is handled.
 RUN: echo 'foo'                                      >  %t-2.in
 RUN: echo 'CHECK: foo'                               >  %t-2.chk
 RUN: echo 'letters then space MY-PREFIX: CHECK: bar' >> %t-2.chk
 RUN: %ProtectFileCheckOutput \
-RUN: FileCheck -vv %t-2.chk -comment-prefixes=MY-PREFIX < %t-2.in 2>&1 | \
+RUN: FileCheck -dump-input=never -vv %t-2.chk -comment-prefixes=MY-PREFIX < %t-2.in 2>&1 | \
 RUN:   FileCheck -DCHECK_LINE=1 %s
 
 # Check the case of multiple user-specified comment prefixes.
 RUN: echo 'foo'               >  %t-3.in
 RUN: echo 'Bar_2: CHECK: Bar' >  %t-3.chk
 RUN: echo 'CHECK: foo'        >> %t-3.chk
 RUN: echo 'Foo_1: CHECK: Foo' >> %t-3.chk
 RUN: echo 'Baz_3: CHECK: Baz' >> %t-3.chk
 RUN: %ProtectFileCheckOutput \
-RUN: FileCheck -vv %t-3.chk -comment-prefixes=Foo_1,Bar_2 \
+RUN: FileCheck -dump-input=never -vv %t-3.chk -comment-prefixes=Foo_1,Bar_2 \
 RUN:           -comment-prefixes=Baz_3 < %t-3.in 2>&1 | \
 RUN:   FileCheck -DCHECK_LINE=2 %s
 
 CHECK: .chk:[[CHECK_LINE]]:8: remark: CHECK: expected string found in input

llvm/test/FileCheck/comment/unused-comment-prefixes.txt

 # Not using comment directives is always fine.
 
 RUN: echo 'foo'        > %t.in
 RUN: echo 'CHECK: foo' > %t.chk
 
 # Check the case of default comment prefixes.
 RUN: %ProtectFileCheckOutput \
-RUN: FileCheck -vv %t.chk < %t.in 2>&1 | FileCheck %s
+RUN: FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 | FileCheck %s
 
 # Specifying non-default comment prefixes doesn't mean you have to use them.
 # For example, they might be applied to an entire test suite via
 # FILECHECK_OPTS or via a wrapper command or substitution.
 RUN: %ProtectFileCheckOutput \
-RUN: FileCheck -vv -comment-prefixes=FOO %t.chk < %t.in 2>&1 | FileCheck %s
+RUN: FileCheck -dump-input=never -vv -comment-prefixes=FOO %t.chk < %t.in 2>&1 | FileCheck %s
 
 CHECK: .chk:1:8: remark: CHECK: expected string found in input

llvm/test/FileCheck/dump-input-enable.txt

 
 ; FileCheck fail, -v => no dump, trace.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -input-file %t.err %t.check -check-prefix=CHECK \
 ; RUN:               -match-full-lines -dump-input=never -v 2>&1 \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=TRACE,ERR,NODUMP
 
 ;--------------------------------------------------
-; Check no -dump-input, which defaults to never.
+; Check no -dump-input, which defaults to fail.
 ;--------------------------------------------------
 
-; FileCheck success, -v => no dump, trace.
+; FileCheck success, -v => no dump, no trace.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: FileCheck -input-file %t.good %t.check -check-prefix=CHECK \
 ; RUN:           -match-full-lines -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines -check-prefixes=TRACE,NODUMP
+; RUN: | FileCheck %s -match-full-lines -allow-empty \
+; RUN:             -check-prefixes=NOTRACE,NODUMP
 
-; FileCheck fail, -v => no dump, trace.
+; FileCheck fail, -v => dump, no trace.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -input-file %t.err %t.check -check-prefix=CHECK \
 ; RUN:               -match-full-lines -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines -check-prefixes=TRACE,ERR,NODUMP
+; RUN: | FileCheck %s -match-full-lines \
+; RUN:                -check-prefixes=NOTRACE,ERR,DUMP-ERR,DUMP-ERR-V
 
 ;--------------------------------------------------
 ; Check -dump-input=fail.
 ;
 ; Include the case without -v, which isn't covered elsewhere.
 ;--------------------------------------------------
 
 ; FileCheck success, no -v => no dump, no trace.

 ; RUN:             -check-prefixes=NOTRACE,NODUMP
 
 ; FileCheck fail, -v => dump, no trace.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -input-file %t.err %t.check -check-prefix=CHECK \
 ; RUN:               -match-full-lines -dump-input=fail -v 2>&1 \
 ; RUN: | FileCheck %s -match-full-lines \
 ; RUN:                -check-prefixes=NOTRACE,ERR,DUMP-ERR,DUMP-ERR-V
 
 ;--------------------------------------------------
-; Check -dump-input-on-failure.
-;--------------------------------------------------
-
-; Command-line option.
-
-; FileCheck success, -v => no dump, no trace.
-; RUN: %ProtectFileCheckOutput \
-; RUN: FileCheck -input-file %t.good %t.check -check-prefix=CHECK \
-; RUN:           -match-full-lines -dump-input-on-failure -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines -allow-empty \
-; RUN:             -check-prefixes=NOTRACE,NODUMP
-
-; FileCheck fail, -v => dump, no trace.
-; RUN: %ProtectFileCheckOutput \
-; RUN: not FileCheck -input-file %t.err %t.check -check-prefix=CHECK \
-; RUN:               -match-full-lines -dump-input-on-failure -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines \
-; RUN:                -check-prefixes=NOTRACE,ERR,DUMP-ERR,DUMP-ERR-V
-
-; FILECHECK_DUMP_INPUT_ON_FAILURE=1.
-
-; FileCheck success, -v => no dump, no trace.
-; RUN: %ProtectFileCheckOutput FILECHECK_DUMP_INPUT_ON_FAILURE=1 \
-; RUN: FileCheck -input-file %t.good %t.check -check-prefix=CHECK \
-; RUN:           -match-full-lines -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines -allow-empty \
-; RUN:                -check-prefixes=NOTRACE,NODUMP
-
-; FileCheck fail, -v => dump, no trace.
-; RUN: %ProtectFileCheckOutput FILECHECK_DUMP_INPUT_ON_FAILURE=1 \
-; RUN: not FileCheck -input-file %t.err %t.check -check-prefix=CHECK \
-; RUN:               -match-full-lines -v 2>&1 \
-; RUN: | FileCheck %s -match-full-lines \
-; RUN:                -check-prefixes=NOTRACE,ERR,DUMP-ERR,DUMP-ERR-V
-
-;--------------------------------------------------
 ; Check -dump-input=always.
 ;--------------------------------------------------
 
 ; FileCheck success, -v => dump, no trace.
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: FileCheck -input-file %t.good %t.check -check-prefix=CHECK \
 ; RUN:           -match-full-lines -dump-input=always -v 2>&1 \
 ; RUN: | FileCheck %s -match-full-lines -check-prefixes=NOTRACE,DUMP-OK

llvm/test/FileCheck/envvar-opts.txt

 ; Create a case that produces a simple diagnostic.
 ; RUN: echo foo > %t.in
 ; CHECK: foo
 ; CHECK: bar
 
 ; RUN: %ProtectFileCheckOutput \
-; RUN: not FileCheck %s -input-file %t.in 2>&1 \
+; RUN: not FileCheck %s -dump-input=never -input-file %t.in 2>&1 \
 ; RUN: | FileCheck -check-prefix QUIET %s
 
 ; RUN: %ProtectFileCheckOutput FILECHECK_OPTS= \
-; RUN: not FileCheck %s -input-file %t.in 2>&1 \
+; RUN: not FileCheck %s -dump-input=never -input-file %t.in 2>&1 \
 ; RUN: | FileCheck -check-prefix QUIET %s
 
 ; RUN: %ProtectFileCheckOutput FILECHECK_OPTS=-v \
-; RUN: not FileCheck %s -input-file %t.in 2>&1 \
+; RUN: not FileCheck %s -dump-input=never -input-file %t.in 2>&1 \
 ; RUN: | FileCheck -check-prefix VERB %s
 
 ; QUIET-NOT: remark: {{CHECK}}: expected string found in input
 ; VERB:      remark: {{CHECK}}: expected string found in input

llvm/test/FileCheck/lit.local.cfg

 #   ; 5.0
 #   ; QUIET-NOT: expected string found in input
 #
 #   ; Check that the FileCheck trace is on when FILECHECK_OPTS=-v.
 #   ; FILECHECK_OPTS must be set after %ProtectFileCheckOutput, which clears
 #   ; FILECHECK_OPTS beforehand.
 #   ;
 #   ; RUN: %ProtectFileCheckOutput FILECHECK_OPTS=-v \
-#   ; RUN: FileCheck -input-file %s %s 2>&1 \
+#   ; RUN: FileCheck -dump-input=never -input-file %s %s 2>&1 \
 #   ; RUN: | FileCheck -check-prefix TRACE %s
 #   ;
 #   ; CHECK: {{[0-9]+\.0}}
 #   ; 5.0
 #   ; TRACE: expected string found in input
 #
 # %ProtectFileCheckOutput's purpose is to ensure correct test results when
 # developers set FileCheck environment variables (e.g.,
 # FILECHECK_OPTS=-dump-input=fail) to tweak the output of FileCheck while
 # debugging tests.  If a developer sets values that affect FileCheck's exit
 # status (e.g., FILECHECK_OPTS=-strict-whitespace), he shouldn't be surprised
 # that test results throughout all test suites are affected.
 config.substitutions.append(('%ProtectFileCheckOutput',
-    'env -u FILECHECK_OPTS -u FILECHECK_DUMP_INPUT_ON_FAILURE'))
+    'env -u FILECHECK_OPTS'))

llvm/test/FileCheck/match-full-lines.txt

 // RUN: %ProtectFileCheckOutput \
-// RUN: not FileCheck -match-full-lines -input-file %s %s  2>&1 \
+// RUN: not FileCheck -match-full-lines -dump-input=never -input-file %s %s  2>&1 \
 // RUN:   | FileCheck --check-prefix=ERROR --implicit-check-not=error: %s
 // RUN: %ProtectFileCheckOutput \
-// RUN: not FileCheck -match-full-lines -strict-whitespace -input-file %s %s \
+// RUN: not FileCheck -match-full-lines -strict-whitespace -dump-input=never -input-file %s %s \
 // RUN: 2>&1 | FileCheck --check-prefix=ERROR-STRICT --check-prefix=ERROR \
 // RUN:                  --implicit-check-not=error: %s
 
 Label 1
 a line
 trailing whitespace   
 trailing more whitespace   
 Label 2

llvm/test/FileCheck/verbose.txt

-; RUN: %ProtectFileCheckOutput FileCheck -input-file %s %s 2>&1 \
+; RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -input-file %s %s 2>&1 \
 ; RUN: | FileCheck -check-prefix QUIET --allow-empty %s
-; RUN: %ProtectFileCheckOutput FileCheck -v -input-file %s %s 2>&1 \
+; RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -v -input-file %s %s 2>&1 \
 ; RUN: | FileCheck --strict-whitespace -check-prefix V %s
-; RUN: %ProtectFileCheckOutput FileCheck -vv -input-file %s %s 2>&1 \
+; RUN: %ProtectFileCheckOutput FileCheck -dump-input=never -vv -input-file %s %s 2>&1 \
 ; RUN: | FileCheck --strict-whitespace -check-prefixes V,VV %s
 
 foo
 bar
 CHECK: foo
 CHECK-NOT: raboof
 CHECK-NEXT: bar
 

llvm/test/Transforms/InstCombine/fortify-folding.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -instcombine -S | FileCheck %s --dump-input-on-failure
+; RUN: opt < %s -instcombine -S | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = common global [60 x i8] zeroinitializer, align 1
 @b = common global [60 x i8] zeroinitializer, align 1
 @.str = private constant [12 x i8] c"abcdefghijk\00"
 
 %struct.__va_list_tag = type { i32, i32, i8*, i8* }

llvm/utils/FileCheck/FileCheck.cpp

static cl::opt<bool> Verbose(
     cl::desc("Print directive pattern matches, or add them to the input dump\n"
              "if enabled.\n"));
 
 static cl::opt<bool> VerboseVerbose(
     "vv", cl::init(false),
     cl::desc("Print information helpful in diagnosing internal FileCheck\n"
              "issues, or add it to the input dump if enabled.  Implies\n"
              "-v.\n"));
-static const char * DumpInputEnv = "FILECHECK_DUMP_INPUT_ON_FAILURE";
-
-static cl::opt<bool> DumpInputOnFailure(
-    "dump-input-on-failure",
-    cl::init(std::getenv(DumpInputEnv) && *std::getenv(DumpInputEnv)),
-    cl::desc("Dump original input to stderr before failing.\n"
-             "The value can be also controlled using\n"
-             "FILECHECK_DUMP_INPUT_ON_FAILURE environment variable.\n"
-             "This option is deprecated in favor of -dump-input=fail.\n"));
 
 // The order of DumpInputValue members affects their precedence, as documented
 // for -dump-input below.
 enum DumpInputValue {
   DumpInputDefault,
   DumpInputNever,
   DumpInputFail,
   DumpInputAlways,
int main(int argc, char **argv) {
   SmallString<4096> InputFileBuffer;
   StringRef InputFileText = FC.CanonicalizeFile(InputFile, InputFileBuffer);
 
   SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(
                             InputFileText, InputFile.getBufferIdentifier()),
                         SMLoc());
 
   if (DumpInput == DumpInputDefault)
-    DumpInput = DumpInputOnFailure ? DumpInputFail : DumpInputNever;
+    DumpInput = DumpInputFail;
 
   std::vector<FileCheckDiag> Diags;
   int ExitCode = FC.checkInput(SM, InputFileText,
                                DumpInput == DumpInputNever ? nullptr : &Diags)
                      ? EXIT_SUCCESS
                      : 1;
   if (DumpInput == DumpInputAlways ||
       (ExitCode == 1 && DumpInput == DumpInputFail)) {

llvm/utils/lit/lit/TestingConfig.py

def fromdefaults(litConfig):
             'LLVM_DISABLE_CRASH_REPORT' : '1',
             }
 
         pass_vars = ['LIBRARY_PATH', 'LD_LIBRARY_PATH', 'SYSTEMROOT', 'TERM',
                      'CLANG', 'LD_PRELOAD', 'ASAN_OPTIONS', 'UBSAN_OPTIONS',
                      'LSAN_OPTIONS', 'ADB', 'ANDROID_SERIAL',
                      'SANITIZER_IGNORE_CVE_2016_2143', 'TMPDIR', 'TMP', 'TEMP',
                      'TEMPDIR', 'AVRLIT_BOARD', 'AVRLIT_PORT',
-                     'FILECHECK_DUMP_INPUT_ON_FAILURE', 'FILECHECK_OPTS',
-                     'VCINSTALLDIR', 'VCToolsinstallDir', 'VSINSTALLDIR',
-                     'WindowsSdkDir', 'WindowsSDKLibVersion']
+                     'FILECHECK_OPTS', 'VCINSTALLDIR', 'VCToolsinstallDir',
+                     'VSINSTALLDIR', 'WindowsSdkDir', 'WindowsSDKLibVersion']
 
         if sys.platform == 'win32':
             pass_vars.append('INCLUDE')
             pass_vars.append('LIB')
             pass_vars.append('PATHEXT')
             environment['PYTHONBUFFERED'] = '1'
 
         for var in pass_vars:

llvm/utils/lit/tests/lit.cfg

 # suites in %{inputs}.  This test suite's results are then determined in part
 # by %{lit}'s textual output, which includes the output of FileCheck calls
 # within %{inputs}'s test suites.  Thus, %{lit} clears environment variables
 # that can affect FileCheck's output.
 config.substitutions.append(('%{inputs}', os.path.join(
     config.test_source_root, 'Inputs')))
 config.substitutions.append(('%{lit}',
     "{env} %{{python}} {lit}".format(
-        env="env -u FILECHECK_OPTS -u FILECHECK_DUMP_INPUT_ON_FAILURE",
+        env="env -u FILECHECK_OPTS",
         lit=os.path.join(lit_path, 'lit.py'))))
 config.substitutions.append(('%{python}', '"%s"' % (sys.executable)))
 
 # Enable coverage.py reporting, assuming the coverage module has been installed
 # and sitecustomize.py in the virtualenv has been modified appropriately.
 if lit_config.params.get('check-coverage', None):
     config.environment['COVERAGE_PROCESS_START'] = os.path.join(
         os.path.dirname(__file__), ".coveragerc")

mlir/test/Analysis/test-callgraph.mlir

-// RUN: mlir-opt %s -test-print-callgraph -split-input-file 2>&1 | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -test-print-callgraph -split-input-file 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : "simple"
 module attributes {test.name = "simple"} {
 
   // CHECK: Node{{.*}}func_a
   func @func_a() {
     return
   }

mlir/test/Analysis/test-dominance.mlir

-// RUN: mlir-opt %s -test-print-dominance -split-input-file 2>&1 | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -test-print-dominance -split-input-file 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : func_condBranch
 func @func_condBranch(%cond : i1) {
   cond_br %cond, ^bb1, ^bb2
 ^bb1:
   br ^exit
 ^bb2:
   br ^exit

 // CHECK-NEXT: Nearest(3, 4) = 4
 // CHECK-NEXT: Nearest(3, 5) = 5
 // CHECK: Nearest(4, 0) = 1
 // CHECK-NEXT: Nearest(4, 1) = 1
 // CHECK-NEXT: Nearest(4, 2) = 2
 // CHECK-NEXT: Nearest(4, 3) = 4
 // CHECK-NEXT: Nearest(4, 4) = 4
 // CHECK-NEXT: Nearest(4, 5) = 5
 No newline at end of file

mlir/test/Analysis/test-liveness.mlir

-// RUN: mlir-opt %s -test-print-liveness -split-input-file 2>&1 | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -test-print-liveness -split-input-file 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : func_empty
 func @func_empty() {
   // CHECK: Block: 0
   // CHECK-NEXT: LiveIn:{{ *$}}
   // CHECK-NEXT: LiveOut:{{ *$}}
   // CHECK-NEXT: BeginLiveness
   // CHECK-NEXT: EndLiveness

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir

-// RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s
 
 gpu.module @test_module {
   // CHECK-LABEL: func @gpu_index_ops()
   func @gpu_index_ops()
       -> (index, index, index, index, index, index,
           index, index, index, index, index, index) {
     // CHECK: = nvvm.read.ptx.sreg.tid.x : !llvm.i32
     %tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index)

mlir/test/Conversion/GPUToROCDL/gpu-to-rocdl.mlir

-// RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s
 
 gpu.module @test_module {
   // CHECK-LABEL: func @gpu_index_ops()
   func @gpu_index_ops()
       -> (index, index, index, index, index, index,
           index, index, index, index, index, index) {
     // CHECK: rocdl.workitem.id.x : !llvm.i32
     %tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index)

mlir/test/Conversion/SCFToGPU/no_blocks_no_threads.mlir

-// RUN: mlir-opt -convert-affine-for-to-gpu="gpu-block-dims=0 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-THREADS %s --dump-input-on-failure
-// RUN: mlir-opt -convert-affine-for-to-gpu="gpu-block-dims=1 gpu-thread-dims=0" %s | FileCheck --check-prefix=CHECK-BLOCKS %s --dump-input-on-failure
+// RUN: mlir-opt -convert-affine-for-to-gpu="gpu-block-dims=0 gpu-thread-dims=1" %s | FileCheck --check-prefix=CHECK-THREADS %s
+// RUN: mlir-opt -convert-affine-for-to-gpu="gpu-block-dims=1 gpu-thread-dims=0" %s | FileCheck --check-prefix=CHECK-BLOCKS %s
 
 // CHECK-THREADS-LABEL: @one_d_loop
 // CHECK-BLOCKS-LABEL: @one_d_loop
 func @one_d_loop(%A : memref<?xf32>, %B : memref<?xf32>) {
   // Bounds of the loop, its range and step.
   // CHECK-THREADS-NEXT: %{{.*}} = constant 0 : index
   // CHECK-THREADS-NEXT: %{{.*}} = constant 42 : index
   // CHECK-THREADS-NEXT: %[[BOUND:.*]] = subi %{{.*}}, %{{.*}} : index

mlir/test/Conversion/SCFToGPU/parallel_loop.mlir

-// RUN: mlir-opt -convert-parallel-loops-to-gpu -split-input-file -verify-diagnostics %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -convert-parallel-loops-to-gpu -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // 2-d parallel loop mapped to block.y and block.x
 
 func @parallel_loop_bidy_bidx(%arg0 : index, %arg1 : index, %arg2 : index,
                               %arg3 : index, %arg4 : index,
                               %buf : memref<?x?xf32>,
                               %res : memref<?x?xf32>) {
   %step = constant 2 : index

mlir/test/Conversion/ShapeToStandard/shape-to-standard.mlir

-// RUN: mlir-opt --split-input-file --convert-shape-to-std --verify-diagnostics %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt --split-input-file --convert-shape-to-std --verify-diagnostics %s | FileCheck %s
 
 // Convert `size` to `index` type.
 // CHECK-LABEL: @size_id
 // CHECK-SAME: (%[[SIZE:.*]]: index)
 func @size_id(%size : !shape.size) -> !shape.size {
   // CHECK: return %[[SIZE]] : index
   return %size : !shape.size
 }

mlir/test/Dialect/GPU/outlining.mlir

-// RUN: mlir-opt -allow-unregistered-dialect -gpu-kernel-outlining -split-input-file -verify-diagnostics %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -allow-unregistered-dialect -gpu-kernel-outlining -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // CHECK: module attributes {gpu.container_module}
 
 // CHECK-LABEL: func @launch()
 func @launch() {
   // CHECK: %[[ARG0:.*]] = "op"() : () -> f32
   %0 = "op"() : () -> (f32)
   // CHECK: %[[ARG1:.*]] = "op"() : () -> memref<?xf32, 1>

mlir/test/Dialect/Linalg/fusion-tensor.mlir

-// RUN: mlir-opt %s -linalg-fusion-for-tensor-ops -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -linalg-fusion-for-tensor-ops -split-input-file | FileCheck %s
 
 // CHECK-DAG: [[MAP0:#[a-zA-Z0-9_]*]] = affine_map<(d0, d1) -> (d0, d1)>
 #map0 = affine_map<(d0, d1) -> (d0, d1)>
 
 // CHECK-LABEL: @add_mul_fusion
 func @add_mul_fusion(%arg0: tensor<?x?xf32>, %arg1 : tensor<?x?xf32>, %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
 {
   %0 = linalg.generic {args_in = 2 : i64, args_out = 1 : i64, indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel", "parallel"]} %arg0, %arg1 {

mlir/test/Dialect/Linalg/fusion.mlir

-// RUN: mlir-opt %s -linalg-fusion -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -linalg-fusion -split-input-file | FileCheck %s
 
 func @f1(%A: memref<?x?xf32, offset: 0, strides: [?, 1]>,
          %B: memref<?x?xf32, offset: 0, strides: [?, 1]>,
          %C: memref<?x?xf32, offset: 0, strides: [?, 1]>,
          %D: memref<?x?xf32, offset: 0, strides: [?, 1]>,
          %E: memref<?x?xf32, offset: 0, strides: [?, 1]>
         ) -> memref<?x?xf32, offset: 0, strides: [?, 1]> {
   %c0 = constant 0 : index

mlir/test/Dialect/Linalg/fusion_indexed_generic.mlir

-// RUN: mlir-opt %s -linalg-fusion -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -linalg-fusion -split-input-file | FileCheck %s
 
 #map = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 #id_2d = affine_map<(d0, d1) -> (d0, d1)>
 #pointwise_2d_trait = {
   args_in = 2,
   args_out = 1,
   indexing_maps = [#id_2d, #id_2d, #id_2d],
   iterator_types = ["parallel", "parallel"]

mlir/test/Dialect/Linalg/parallel_loops.mlir

-// RUN: mlir-opt %s -convert-linalg-to-parallel-loops -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -convert-linalg-to-parallel-loops -split-input-file | FileCheck %s
 
 #map0 = affine_map<(d0, d1) -> (d0, d1)>
 func @linalg_generic_sum(%lhs: memref<2x2xf32>,
                          %rhs: memref<2x2xf32>,
                          %sum: memref<2x2xf32>) {
   linalg.generic {
     args_in = 2 : i64,
     args_out = 1 : i64,

mlir/test/Dialect/Linalg/tensors-to-buffers.mlir

-// RUN: mlir-opt -convert-linalg-on-tensors-to-buffers -buffer-placement -split-input-file %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -convert-linalg-on-tensors-to-buffers -buffer-placement -split-input-file %s | FileCheck %s
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @muliple_results_generic_op
 func @muliple_results_generic_op(%arg0: tensor<4xf32>) -> (tensor<4xf32>, tensor<4xf32>) {
     %0, %1 = linalg.generic {args_in = 1 : i64, args_out = 2 : i64, indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} %arg0 {
     ^bb0(%gen_arg1: f32):
         %tmp1 = exp %gen_arg1 : f32

mlir/test/Dialect/Linalg/tile_conv_padding.mlir

-// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,0,0,4" | FileCheck %s -check-prefix=TILE-23004 --dump-input-on-failure
-// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2" | FileCheck %s -check-prefix=TILE-20000 --dump-input-on-failure
+// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,0,0,4" | FileCheck %s -check-prefix=TILE-23004
+// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2" | FileCheck %s -check-prefix=TILE-20000
 
 // TILE-23004-DAG: #[[strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
 // TILE-20000-DAG: #[[strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
 // TILE-20000-DAG: #[[minmap:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)>
 
 func @conv_padding(%arg0: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg1: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg2: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>) {
   linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], padding = dense<[[1, 1], [0, 1]]> : tensor<2x2xi64>, strides = [30, 40]} : memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>
   return

mlir/test/Dialect/Linalg/tile_parallel.mlir

-// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=2" | FileCheck %s -check-prefix=TILE-2 --dump-input-on-failure
-// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=0,2" | FileCheck %s -check-prefix=TILE-02 --dump-input-on-failure
-// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=0,0,2" | FileCheck %s -check-prefix=TILE-002 --dump-input-on-failure
-// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=2,3,4" | FileCheck %s -check-prefix=TILE-234 --dump-input-on-failure
+// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=2" | FileCheck %s -check-prefix=TILE-2
+// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=0,2" | FileCheck %s -check-prefix=TILE-02
+// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=0,0,2" | FileCheck %s -check-prefix=TILE-002
+// RUN: mlir-opt %s -linalg-tile-to-parallel-loops="linalg-tile-sizes=2,3,4" | FileCheck %s -check-prefix=TILE-234
 
 #id_2d = affine_map<(i, j) -> (i, j)>
 #pointwise_2d_trait = {
   args_in = 2,
   args_out = 1,
   indexing_maps = [#id_2d, #id_2d, #id_2d],
   iterator_types = ["parallel", "parallel"]
 }

mlir/test/Dialect/SCF/ops.mlir

-// RUN: mlir-opt %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s | FileCheck %s
 // Verify the printed output can be parsed.
-// RUN: mlir-opt %s | mlir-opt | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
 // Verify the generic form can be parsed.
-// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt | FileCheck %s
 
 func @std_for(%arg0 : index, %arg1 : index, %arg2 : index) {
   scf.for %i0 = %arg0 to %arg1 step %arg2 {
     scf.for %i1 = %arg0 to %arg1 step %arg2 {
       %min_cmp = cmpi "slt", %i0, %i1 : index
       %min = select %min_cmp, %i0, %i1 : index
       %max_cmp = cmpi "sge", %i0, %i1 : index
       %max = select %max_cmp, %i0, %i1 : index

mlir/test/Dialect/SCF/parallel-loop-fusion.mlir

-// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-fusion)' -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-fusion)' -split-input-file | FileCheck %s
 
 func @fuse_empty_loops() {
   %c2 = constant 2 : index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   scf.parallel (%i, %j) = (%c0, %c0) to (%c2, %c2) step (%c1, %c1) {
     scf.yield
   }

mlir/test/Dialect/SCF/parallel-loop-specialization.mlir

-// RUN: mlir-opt %s -parallel-loop-specialization -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -parallel-loop-specialization -split-input-file | FileCheck %s
 
 #map0 = affine_map<()[s0, s1] -> (1024, s0 - s1)>
 #map1 = affine_map<()[s0, s1] -> (64, s0 - s1)>
 
 func @parallel_loop(%outer_i0: index, %outer_i1: index, %A: memref<?x?xf32>, %B: memref<?x?xf32>,
                     %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index

mlir/test/Dialect/SCF/parallel-loop-tiling.mlir

-// RUN: mlir-opt %s -pass-pipeline='func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -pass-pipeline='func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s
 
 func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
                     %arg3 : index, %arg4 : index, %arg5 : index,
         %A: memref<?x?xf32>, %B: memref<?x?xf32>,
                     %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) {
     %B_elem = load %B[%i0, %i1] : memref<?x?xf32>
     %C_elem = load %C[%i0, %i1] : memref<?x?xf32>

mlir/test/Dialect/Shape/ops.mlir

-// RUN: mlir-opt -split-input-file %s | mlir-opt | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -split-input-file %s | mlir-opt | FileCheck %s
 // Verify the printed output can be parsed.
-// RUN: mlir-opt %s | mlir-opt | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s | mlir-opt | FileCheck %s
 // Verify the generic form can be parsed.
-// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt | FileCheck %s
 
 // CHECK-LABEL: shape_num_elements
 func @shape_num_elements(%shape : !shape.shape) -> !shape.size {
   %init = shape.const_size 0
   %num_elements = shape.reduce(%shape, %init) -> !shape.size {
     ^bb0(%index: index, %dim: !shape.size, %lci: !shape.size):
       %acc = "shape.add"(%lci, %dim) : (!shape.size, !shape.size) -> !shape.size
       shape.yield %acc : !shape.size

mlir/test/Dialect/Shape/shape-to-shape.mlir

-// RUN: mlir-opt -shape-to-shape-lowering -split-input-file %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -shape-to-shape-lowering -split-input-file %s | FileCheck %s
 
 // CHECK-LABEL: func @num_elements_to_reduce(
 // CHECK-SAME:    [[ARG:%.*]]: !shape.shape) -> [[SIZE_TY:!.*]] {
 func @num_elements_to_reduce(%shape : !shape.shape) -> !shape.size {
   %num_elements = shape.num_elements %shape
   return %num_elements : !shape.size
 }
 // CHECK: [[C1:%.*]] = shape.const_size 1
 // CHECK: [[NUM_ELEMENTS:%.*]] = shape.reduce([[ARG]], [[C1]])  -> [[SIZE_TY]]
 // CHECK: ^bb0({{.*}}: index, [[DIM:%.*]]: [[SIZE_TY]], [[ACC:%.*]]: [[SIZE_TY]]
 // CHECK:   [[NEW_ACC:%.*]] = shape.mul [[DIM]], [[ACC]]
 // CHECK:   shape.yield [[NEW_ACC]] : [[SIZE_TY]]
 // CHECK: }
 // CHECK: return [[NUM_ELEMENTS]] : [[SIZE_TY]]
 

mlir/test/Dialect/Standard/expand-atomic.mlir

-// RUN: mlir-opt %s -expand-atomic -split-input-file | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -expand-atomic -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @atomic_rmw_to_generic
 // CHECK-SAME: ([[F:%.*]]: memref<10xf32>, [[f:%.*]]: f32, [[i:%.*]]: index)
 func @atomic_rmw_to_generic(%F: memref<10xf32>, %f: f32, %i: index) -> f32 {
   %x = atomic_rmw "maxf" %f, %F[%i] : (f32, memref<10xf32>) -> f32
   return %x : f32
 }
 // CHECK: %0 = std.generic_atomic_rmw %arg0[%arg2] : memref<10xf32> {

mlir/test/Dialect/Vector/vector-contract-transforms.mlir

-// RUN: mlir-opt %s -test-vector-contraction-conversion | FileCheck %s --dump-input-on-failure
-// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-lower-matrix-intrinsics=1 | FileCheck %s --check-prefix=MATRIX --dump-input-on-failure
-// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-outerproduct=1 | FileCheck %s --check-prefix=OUTERPRODUCT --dump-input-on-failure
+// RUN: mlir-opt %s -test-vector-contraction-conversion | FileCheck %s
+// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-lower-matrix-intrinsics=1 | FileCheck %s --check-prefix=MATRIX
+// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-outerproduct=1 | FileCheck %s --check-prefix=OUTERPRODUCT
 
 #dotp_accesses = [
   affine_map<(i) -> (i)>,
   affine_map<(i) -> (i)>,
   affine_map<(i) -> ()>
 ]
 #dotp_trait = {
   indexing_maps = #dotp_accesses,

mlir/test/Dialect/Vector/vector-flat-transforms.mlir

-// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-flat-transpose=1 | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -test-vector-contraction-conversion=vector-flat-transpose=1 | FileCheck %s
 
 // Tests for lowering 2-D vector.transpose into vector.flat_transpose.
 //
 // TODO(ajcbik,ntv): having ShapeCastOp2DDownCastRewritePattern and
 //                   ShapeCastOp2DUpCastRewritePattern too early in
 //                   the greedy rewriting patterns misses opportunities
 //                   to fold shape casts!
 

mlir/test/EDSC/builder-api-test.cpp

 //===- builder-api-test.cpp - Tests for Declarative Builder APIs ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// RUN: mlir-edsc-builder-api-test | FileCheck %s -dump-input-on-failure
+// RUN: mlir-edsc-builder-api-test | FileCheck %s
 
 #include "mlir/Dialect/Affine/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Linalg/EDSC/Builders.h"
 #include "mlir/Dialect/Linalg/EDSC/Intrinsics.h"
 #include "mlir/Dialect/SCF/EDSC/Intrinsics.h"
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/Dialect/Vector/EDSC/Intrinsics.h"
 #include "mlir/EDSC/Builders.h"

mlir/test/IR/print-op-local-scope.mlir

-// RUN: mlir-opt -allow-unregistered-dialect %s -mlir-print-local-scope | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -allow-unregistered-dialect %s -mlir-print-local-scope | FileCheck %s
 
 // CHECK: "foo.op"() : () -> memref<?xf32, affine_map<(d0) -> (d0 * 2)>>
 "foo.op"() : () -> (memref<?xf32, affine_map<(d0) -> (2*d0)>>)
 

mlir/test/Transforms/buffer-placement-preparation-allowed-memref-results.mlir

-// RUN: mlir-opt -test-buffer-placement-preparation-with-allowed-memref-results -split-input-file %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -test-buffer-placement-preparation-with-allowed-memref-results -split-input-file %s | FileCheck %s
 
 // Since allowMemrefEscaping is on for Buffer Placement in this test pass, all
 // tensor typed function results are converted to memref and remain as function
 // results. All memref typed function results will escape from the deallocation
 // phase of Buffer Placement.
 
 // CHECK-LABEL: func @void_function_signature_conversion
 func @void_function_signature_conversion(%arg0: tensor<4x8xf32>) {

mlir/test/Transforms/buffer-placement-preparation.mlir

-// RUN: mlir-opt -test-buffer-placement-preparation -split-input-file %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -test-buffer-placement-preparation -split-input-file %s | FileCheck %s
 
 // CHECK-LABEL: func @func_signature_conversion
 func @func_signature_conversion(%arg0: tensor<4x8xf32>) {
     return
 }
 // CHECK: ({{.*}}: memref<4x8xf32>) {
 
 // -----

mlir/test/Transforms/buffer-placement.mlir

-// RUN: mlir-opt -buffer-placement -split-input-file %s | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -buffer-placement -split-input-file %s | FileCheck %s
 
 // This file checks the behaviour of BufferPlacement pass for moving Alloc and Dealloc
 // operations and inserting the missing the DeallocOps in their correct positions.
 
 // Test Case:
 //    bb0
 //   /   \
 //  bb1  bb2 <- Initial position of AllocOp

mlir/test/Transforms/canonicalize.mlir

-// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s -dump-input-on-failure
+// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(canonicalize)' -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @test_subi_zero
 func @test_subi_zero(%arg0: i32) -> i32 {
   // CHECK-NEXT: %c0_i32 = constant 0 : i32
   // CHECK-NEXT: return %c0
   %y = subi %arg0, %arg0 : i32
   return %y: i32
 }

mlir/test/Transforms/sccp-callgraph.mlir

-// RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s -dump-input-on-failure
-// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED -dump-input-on-failure
+// RUN: mlir-opt -allow-unregistered-dialect %s -sccp -split-input-file | FileCheck %s
+// RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline="module(sccp)" -split-input-file | FileCheck %s --check-prefix=NESTED
 
 /// Check that a constant is properly propagated through the arguments and
 /// results of a private function.
 
 // CHECK-LABEL: func @private(
 func @private(%arg0 : i32) -> i32 attributes { sym_visibility = "private" } {
   // CHECK: %[[CST:.*]] = constant 1 : i32
   // CHECK: return %[[CST]] : i32

mlir/test/mlir-tblgen/op-attribute.td

-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL --dump-input-on-failure
-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF --dump-input-on-failure
-// RUN: mlir-tblgen -print-records -I %S/../../include %s | FileCheck %s --check-prefix=RECORD --dump-input-on-failure
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
+// RUN: mlir-tblgen -print-records -I %S/../../include %s | FileCheck %s --check-prefix=RECORD
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/op-decl.td

-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck --dump-input-on-failure %s
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck  %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "NS";

mlir/test/mlir-tblgen/op-derived-attribute.mlir

-// RUN: mlir-opt -test-derived-attr -verify-diagnostics %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -test-derived-attr -verify-diagnostics %s | FileCheck %s
 
 // CHECK-LABEL: verifyDerivedAttributes
 func @verifyDerivedAttributes() {
   // expected-remark @+2 {{element_dtype = f32}}
   // expected-remark @+1 {{size = 320}}
   %0 = "test.derived_type_attr"() : () -> tensor<10xf32>
   // expected-remark @+2 {{element_dtype = i79}}
   // expected-remark @+1 {{size = 948}}
   %1 = "test.derived_type_attr"() : () -> tensor<12xi79>
 
   return
 }

mlir/test/mlir-tblgen/op-format-spec.td

-// RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../include %s -o=%t 2>&1 | FileCheck %s --dump-input-on-failure
+// RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../include %s -o=%t 2>&1 | FileCheck %s
 
 // This file contains tests for the specification of the declarative op format.
 
 include "mlir/IR/OpBase.td"
 
 def TestDialect : Dialect {
   let name = "test";
 }

mlir/test/mlir-tblgen/op-interface.td

-// RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL --dump-input-on-failure
-// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=OP_DECL --dump-input-on-failure
+// RUN: mlir-tblgen -gen-op-interface-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
+// RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=OP_DECL
 
 include "mlir/IR/OpBase.td"
 
 def TestOpInterface : OpInterface<"TestOpInterface"> {
   let description = [{some op interface description}];
 
   let methods = [
     InterfaceMethod<

mlir/test/mlir-tblgen/pattern.mlir

-// RUN: mlir-opt -test-patterns -mlir-print-debuginfo %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt -test-patterns -mlir-print-debuginfo %s | FileCheck %s
 
 // CHECK-LABEL: verifyFusedLocs
 func @verifyFusedLocs(%arg0 : i32) -> i32 {
   %0 = "test.op_a"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
   %result = "test.op_a"(%0) {attr = 20 : i32} : (i32) -> i32 loc("b")
 
   // CHECK: "test.op_b"(%arg0) {attr = 10 : i32} : (i32) -> i32 loc("a")
   // CHECK: "test.op_b"(%arg0) {attr = 20 : i32} : (i32) -> i32 loc(fused["b", "a"])

mlir/test/mlir-tblgen/predicate.td

-// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --dump-input-on-failure
+// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/return-types.mlir

-// RUN: mlir-opt %s -test-return-type -split-input-file -verify-diagnostics | FileCheck %s --dump-input-on-failure
+// RUN: mlir-opt %s -test-return-type -split-input-file -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: testCreateFunctions
 // This function tests invoking the create method with different inference
 // methods. The attributes of the ops inside are used to test creation.
 func @testCreateFunctions(%arg0 : tensor<10xf32>, %arg1 : tensor<20xi32>) {
 // CHECK: "test.no_attributes"
   %good = "test.no_attributes"(%arg0, %arg0) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10xf32>
 // CHECK: "test.op_with_shaped_type_infer_type_if"