[EarlyCSE] Verify hash code in regression tests

[bryanpkc]

Summary

As discussed in D86843, -earlycse-debug-hash should be used in more regression
tests to catch inconsistency between the hashing and the equivalence check.
The options is also changed to be enabled by default if LLVM is built with
EXPENSIVE_CHECKS defined.

[lebedev.ri]

Thanks!

Test changes are certainly LGTM, may be best to commit them separately.

For the record, i don't know just how slower this makes EarlyCSE in EXPENSIVE_CHECKS build,
but i can't imagine having lurking nondeterminism with an easy way to catch it is better.
@spatel thoughts on the switch?

[spatel]

In D86863#2247060, @lebedev.ri wrote:

Thanks!

Test changes are certainly LGTM, may be best to commit them separately.

For the record, i don't know just how slower this makes EarlyCSE in EXPENSIVE_CHECKS build,
but i can't imagine having lurking nondeterminism with an easy way to catch it is better.
@spatel thoughts on the switch?

I also don't know how to detect the underlying bug (inconsistent hashing) in a better way. EXPENSIVE_CHECKS sounds like the right enabling flag to me.

Whether we should do this as a part of normal regression testing, I'm not sure. I know of 1 other example of normalizing an expensive testing scenario by explicitly setting a flag in RUN lines: targets like PowerPC set "-verify-machineinstr" on all CodeGen tests for better coverage. But IIUC, that does extra checking without altering the normal codepaths. Changing the debug hash is different because we are no longer testing the underlying behavior that a normal user would experience. Are we creating a testing blind spot by changing these tests?

Adding some more potential reviewers.

[lebedev.ri]

FWIW personally i'm only somewhat cautious about the compile time impact.

In D86863#2247283, @spatel wrote:

In D86863#2247060, @lebedev.ri wrote:

Thanks!

Test changes are certainly LGTM, may be best to commit them separately.

For the record, i don't know just how slower this makes EarlyCSE in EXPENSIVE_CHECKS build,
but i can't imagine having lurking nondeterminism with an easy way to catch it is better.
@spatel thoughts on the switch?

I also don't know how to detect the underlying bug (inconsistent hashing) in a better way. EXPENSIVE_CHECKS sounds like the right enabling flag to me.

Whether we should do this as a part of normal regression testing, I'm not sure. I know of 1 other example of normalizing an expensive testing scenario by explicitly setting a flag in RUN lines: targets like PowerPC set "-verify-machineinstr" on all CodeGen tests for better coverage.

But IIUC, that does extra checking without altering the normal codepaths. Changing the debug hash is different because we are no longer testing the underlying behavior that a normal user would experience. Are we creating a testing blind spot by changing these tests?

This is a non-issue, because these tests aren't tests for DenseMap,
and the only thing that flag does, is causes all hashes to collide,
thus forcing DenseMap to call DenseMapInfo<SimpleValue>::isEqual(),
that verifies this invariant.
So this causes strictly larger code coverage footprint, not smaller.

Adding some more potential reviewers.

[spatel]

In D86863#2247308, @lebedev.ri wrote:

But IIUC, that does extra checking without altering the normal codepaths. Changing the debug hash is different because we are no longer testing the underlying behavior that a normal user would experience. Are we creating a testing blind spot by changing these tests?

This is a non-issue, because these tests aren't tests for DenseMap,
and the only thing that flag does, is causes all hashes to collide,
thus forcing DenseMap to call DenseMapInfo<SimpleValue>::isEqual(),
that verifies this invariant.
So this causes strictly larger code coverage footprint, not smaller.

Ok, that sounds reasonable to me. But please wait at least a day to commit in case anyone else has comments.

llvm/test/Transforms/InstSimplify/ConstProp/math-1.ll

2

Several tests like this are in the InstSimplify test directory, but not using -instsimplify directly. I think it would be better to update them to not use -early-cse at all.

Also, if there is some whitespace issue causing the entire file to update here, it would be better to fix that as a preliminary cleanup.

[nikic]

For the record, i don't know just how slower this makes EarlyCSE in EXPENSIVE_CHECKS build

I would expect "a lot" because this effectively makes EarlyCSE compare every instruction with every other instruction, i.e. quadratic in the function size. Might be too much even for EXPENSIVE_CHECKS, though I can't say I'm familiar with conventions for those.

[efriedma]

It would be good to keep EXPENSIVE_CHECKS in a state where it can actually be used as a replacement for a normal compiler compiler if you're okay with a 10x-100x slowdown. Quadratic/cubic time growth tends to make the resulting compiler completely unusable for compiling practical code: code that contains certain patterns takes effectively forever to compile.

[JosephTremoulet]

Yeah, the potential for quadratic explosion is why I didn't hook this flag up to expensive checks when I added it. It occurs to me now that if we want, we could presumably have some cutoff counter so that after inserting 300 instructions or whatever limit is reasonable, we start hashing normally. We'd have to empty the table and repopulate it with the normal hash when we cut over, but that should be doable I think (it's similar to what the table does internally when it grows).

[lebedev.ri]

I think it would be best to split this into two parts: the test changes, and potential default flip.

[bryanpkc]

Removed the change to the default value of EarlyCSEDebugHash as per @lebedev.ri's suggestion.

[lebedev.ri]

Thanks, this part still LG.

[bryanpkc]

llvm/test/Transforms/InstSimplify/ConstProp/math-1.ll

2

Do you mean I should replace -early-cse with -inst-simplify in these tests?

I have got rid of the whitespace-related diffs.

[bryanpkc]

llvm/test/Transforms/InstSimplify/ConstProp/math-1.ll

2

If you don't mind, I would prefer to consider changing the InstSimplify tests in a separate patch.

[spatel]

llvm/test/Transforms/InstSimplify/ConstProp/math-1.ll

2

No problem - and yes, I think we just replace -early-cse in each RUN line for this set of tests that is checking for constant propagation.

llvm/test/Analysis/MemorySSA/pr41853.ll

-; RUN: opt -S -memoryssa -loop-simplify -early-cse-memssa -verify-memoryssa %s | FileCheck %s
+; RUN: opt -S -memoryssa -loop-simplify -early-cse-memssa -earlycse-debug-hash -verify-memoryssa %s | FileCheck %s
 ; RUN: opt -S -memoryssa -loop-simplify -early-cse-memssa -enable-mssa-loop-dependency -verify-memoryssa %s | FileCheck %s
 ; REQUIRES: asserts
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: @func()
 define void @func() {
   br i1 undef, label %bb5, label %bb3
 
 bb5:                                              ; preds = %bb5, %0
   store i16 undef, i16* undef
   br i1 undef, label %bb5, label %bb3
 
 bb3:                                              ; preds = %bb5, %0
   ret void
 }

llvm/test/CodeGen/PowerPC/no-dup-of-bdnz.ll

-; RUN: opt -early-cse-memssa -loop-rotate -licm -loop-rotate -S %s -o - | FileCheck %s
+; RUN: opt -early-cse-memssa -earlycse-debug-hash -loop-rotate -licm -loop-rotate -S %s -o - | FileCheck %s
 ; ModuleID = 'bugpoint-reduced-simplified.bc'
 source_filename = "bugpoint-output-8903f29.bc"
 target datalayout = "e-m:e-i64:64-n32:64"
 target triple = "powerpc64le-unknown-linux-gnu"
 
 define void @test(i64 %arg.ssa, i64 %arg.nb) local_unnamed_addr {
 ; Ensure that loop rotation doesn't duplicate the call to
 ; llvm.loop.decrement

llvm/test/CodeGen/X86/mmx-bitcast-fold.ll

-; RUN: opt -mtriple=x86_64-- -early-cse < %s -S | FileCheck %s
+; RUN: opt -mtriple=x86_64-- -early-cse -earlycse-debug-hash < %s -S | FileCheck %s
 
 ; CHECK: @foo(x86_mmx bitcast (double 0.000000e+00 to x86_mmx))
 
 define void @bar() {
 entry:
   %0 = bitcast double 0.0 to x86_mmx
   %1 = call x86_mmx @foo(x86_mmx %0)
   ret void
 }
 
 declare x86_mmx @foo(x86_mmx)

llvm/test/DebugInfo/Generic/pr40628.ll

-; RUN: opt -early-cse -S %s -o - | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S %s -o - | FileCheck %s
 
 ; PR40628: The first load below is determined to be redundant by EarlyCSE.
 ; During salvaging, the corresponding dbg.value could have a DW_OP_deref used
 ; in its DIExpression to represent the redundant operation -- however LLVM
 ; cannot currently determine that the subsequent store should terminate the
 ; variables location range. A debugger would display zero for the "redundant"
 ; variable after stepping onto the return instruction.
 

llvm/test/DebugInfo/salvage-cast-debug-info.ll

-; RUN: opt %s -debugify -early-cse -S | FileCheck %s
+; RUN: opt %s -debugify -early-cse -earlycse-debug-hash -S | FileCheck %s
 define i32 @foo(i64 %nose, i32 %more) {
 ; CHECK-LABEL: @foo(
 ; CHECK: call void @llvm.dbg.value(metadata i64 %nose, metadata [[V1:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned
 ; CHECK: call void @llvm.dbg.value(metadata i64 %nose.shift, metadata [[V2:![0-9]+]]
 ; CHECK: call void @llvm.dbg.value(metadata i64 %nose.shift, metadata [[V3:![0-9]+]], metadata !DIExpression(DW_OP_LLVM_convert, 64, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_unsigned
 
 entry:
   %nose.trunc = trunc i64 %nose to i32

llvm/test/Feature/OperandBundles/early-cse.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 ; While it is normally okay to do memory optimizations over calls to
 ; @readonly_function and @readnone_function, we cannot do that if
 ; they're carrying unknown operand bundles since the presence of
 ; unknown operand bundles implies arbitrary memory effects.
 
 declare void @readonly_function() readonly nounwind
 declare void @readnone_function() readnone nounwind

llvm/test/Feature/OperandBundles/special-state.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 ; This test isn't directly related to EarlyCSE or varargs.  It is just
 ; using these as a vehicle for testing the correctness of
 ; haveSameSpecialState around operand bundles.
 
 declare i32 @foo(...)
 
 define i32 @f() {

llvm/test/Other/debugcounter-earlycse.ll

 ; REQUIRES: asserts
-; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse  < %s 2>&1 | FileCheck %s
+; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse -earlycse-debug-hash < %s 2>&1 | FileCheck %s
 ;; Test that, with debug counters on, we only optimize the second CSE opportunity.
 define i32 @test(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    %add1 = add i32 %a, %b
 ; CHECK-NEXT:    %add2 = add i32 %a, %b
 ; CHECK-NEXT:    %add4 = add i32 %a, %b
 ; CHECK-NEXT:    %ret1 = add i32 %add1, %add2

llvm/test/Other/invariant.group.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 ; RUN: opt -S -gvn < %s | FileCheck %s
 ; RUN: opt -S -newgvn < %s | FileCheck %s
 ; RUN: opt -S -O3 < %s | FileCheck %s
 
 ; These tests checks if passes with CSE functionality can do CSE on
 ; launder.invariant.group, that is prohibited if there is a memory clobber
 ; between barriers call.
 

 ; CHECK-NEXT: declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 
 ; CHECK: Function Attrs: nounwind readnone speculatable willreturn{{$}}
 ; CHECK-NEXT: declare i8* @llvm.strip.invariant.group.p0i8(i8*)
 declare i8* @llvm.strip.invariant.group.p0i8(i8*)
 
 
-!0 = !{}
+!0 = !{}
 

llvm/test/Other/opt-bisect-legacy-pass-manager.ll

 ; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f1)
 ; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f2)
 ; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (f3)
 ; CHECK-NOT-INLINE: BISECT: NOT running pass ({{[0-9]+}}) Function Integration/Inlining on SCC (<<null function>>)
 
 
 ; Test a function pass.
 
-; RUN: opt -disable-output -disable-verify -early-cse -opt-bisect-limit=-1 \
+; RUN: opt -disable-output -disable-verify -early-cse -earlycse-debug-hash -opt-bisect-limit=-1 \
 ; RUN:     %s 2>&1 | FileCheck %s --check-prefix=CHECK-EARLY-CSE
 ; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f1)
 ; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f2)
 ; CHECK-EARLY-CSE: BISECT: running pass ({{[0-9]+}}) Early CSE on function (f3)
 
-; RUN: opt -disable-output -disable-verify -early-cse -opt-bisect-limit=0 %s \
-; RUN:     2>&1 | FileCheck %s --check-prefix=CHECK-NOT-EARLY-CSE
+; RUN: opt -disable-output -disable-verify -early-cse -earlycse-debug-hash -opt-bisect-limit=0 \
+; RUN:     %s 2>&1 | FileCheck %s --check-prefix=CHECK-NOT-EARLY-CSE
 ; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f1)
 ; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f2)
 ; CHECK-NOT-EARLY-CSE: BISECT: NOT running pass ({{[0-9]+}}) Early CSE on function (f3)
 
 
 ; Test a loop pass.
 
 ; RUN: opt -disable-output -disable-verify -loop-reduce -opt-bisect-limit=-1 \

llvm/test/Other/print-debug-counter.ll

 ; REQUIRES: asserts
 
-; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse \
+; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse -earlycse-debug-hash \
 ; RUN:        -debug-counter=newgvn-vn-skip=1,newgvn-vn-count=2 -newgvn \
 ; RUN:        -instcombine -print-debug-counter < %s 2>&1 | FileCheck %s
 ;; Test debug counter prints correct info in right order.
 ; CHECK-LABEL: Counters and values:
 ; CHECK:       early-cse
 ; CHECK-SAME:  {4,1,1}
 ; CHECK:       instcombine-visit
 ; CHECK-SAME:  {12,0,-1}

llvm/test/Transforms/EarlyCSE/AArch64/intrinsics.ll

-; RUN: opt < %s -S -mtriple=aarch64-none-linux-gnu -mattr=+neon -early-cse | FileCheck %s
+; RUN: opt < %s -S -mtriple=aarch64-none-linux-gnu -mattr=+neon -early-cse -earlycse-debug-hash | FileCheck %s
 ; RUN: opt < %s -S -mtriple=aarch64-none-linux-gnu -mattr=+neon -basic-aa -early-cse-memssa | FileCheck %s
 ; RUN: opt < %s -S -mtriple=aarch64-none-linux-gnu -mattr=+neon -passes=early-cse | FileCheck %s
 ; RUN: opt < %s -S -mtriple=aarch64-none-linux-gnu -mattr=+neon -aa-pipeline=basic-aa -passes=early-cse-memssa | FileCheck %s
 
 define <4 x i32> @test_cse(i32* %a, [2 x <4 x i32>] %s.coerce, i32 %n) {
 entry:
 ; Check that @llvm.aarch64.neon.ld2 is optimized away by Early CSE.
 ; CHECK-LABEL: @test_cse

llvm/test/Transforms/EarlyCSE/AArch64/ldstN.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 ; RUN: opt -S -basic-aa -early-cse-memssa < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64--linux-gnu"
 
 declare { <4 x i16>, <4 x i16>, <4 x i16>, <4 x i16> } @llvm.aarch64.neon.ld4.v4i16.p0v4i16(<4 x i16>*)
 
 ; Although the store and the ld4 are using the same pointer, the
 ; data can not be reused because ld4 accesses multiple elements.

llvm/test/Transforms/EarlyCSE/AMDGPU/intrinsics.ll

-; RUN: opt < %s -S -mtriple=amdgcn-- -early-cse | FileCheck %s
+; RUN: opt < %s -S -mtriple=amdgcn-- -early-cse -earlycse-debug-hash | FileCheck %s
 
 ; CHECK-LABEL: @no_cse
 ; CHECK: call i32 @llvm.amdgcn.s.buffer.load.i32(<4 x i32> %in, i32 0, i32 0)
 ; CHECK: call i32 @llvm.amdgcn.s.buffer.load.i32(<4 x i32> %in, i32 4, i32 0)
 define void @no_cse(i32 addrspace(1)* %out, <4 x i32> %in) {
   %a = call i32 @llvm.amdgcn.s.buffer.load.i32(<4 x i32> %in, i32 0, i32 0)
   %b = call i32 @llvm.amdgcn.s.buffer.load.i32(<4 x i32> %in, i32 4, i32 0)
   %c = add i32 %a, %b

llvm/test/Transforms/EarlyCSE/AMDGPU/memrealtime.ll

-; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -early-cse-memssa < %s | FileCheck %s
+; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -early-cse-memssa -earlycse-debug-hash < %s | FileCheck %s
 target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
 
 ; CHECK-LABEL: @memrealtime(
 ; CHECK: call i64 @llvm.amdgcn.s.memrealtime()
 ; CHECK: call i64 @llvm.amdgcn.s.memrealtime()
 define amdgpu_kernel void @memrealtime(i64 %cycles) #0 {
 entry:
   %0 = tail call i64 @llvm.amdgcn.s.memrealtime()

llvm/test/Transforms/EarlyCSE/PowerPC/read-reg.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 ; RUN: opt -S -basic-aa -early-cse-memssa < %s | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 ; Function Attrs: nounwind
 define i64 @f(i64 %x) #0 {
 entry:
   %0 = call i64 @llvm.read_register.i64(metadata !0)

llvm/test/Transforms/EarlyCSE/X86/preserve_memoryssa.ll

-; RUN: opt < %s -early-cse-memssa -verify-memoryssa -disable-output
+; RUN: opt < %s -early-cse-memssa -earlycse-debug-hash -verify-memoryssa -disable-output
 ; REQUIRES: asserts
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Tests below highlight scenarios where EarlyCSE does not preserve MemorySSA
 ; optimized accesses. Current MemorySSA verify will accept these.
 

llvm/test/Transforms/EarlyCSE/and_or.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 
 define i32 @test_01(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test_01(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[COND:%.*]] = icmp slt i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[COND]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
 ; CHECK:       if.true:

llvm/test/Transforms/EarlyCSE/atomics.ll

-; RUN: opt < %s -S -early-cse | FileCheck %s
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
 
 ; CHECK-LABEL: @test12(
 define i32 @test12(i1 %B, i32* %P1, i32* %P2) {
   %load0 = load i32, i32* %P1
   %1 = load atomic i32, i32* %P2 seq_cst, align 4
   %load1 = load i32, i32* %P1
   %sel = select i1 %B, i32 %load0, i32 %load1

llvm/test/Transforms/EarlyCSE/basic.ll

-; RUN: opt < %s -S -early-cse | FileCheck %s
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
 ; RUN: opt < %s -S -passes=early-cse | FileCheck %s
 
 declare void @llvm.assume(i1) nounwind
 
 ; CHECK-LABEL: @test1(
 define void @test1(i8 %V, i32 *%P) {
   %A = bitcast i64 42 to double  ;; dead

llvm/test/Transforms/EarlyCSE/conditional.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 
 ; Can we CSE a known condition to a constant?
 define i1 @test(i8* %p) {
 ; CHECK-LABEL: @test
 entry:
   %cnd1 = icmp eq i8* %p, null
   br i1 %cnd1, label %taken, label %untaken

llvm/test/Transforms/EarlyCSE/const-speculation.ll

-; RUN: opt -early-cse -S %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S %s | FileCheck %s
 
 %mystruct = type { i32 }
 
 ; @var is global so that *every* GEP argument is Constant.
 @var = external global %mystruct
 
 ; Control flow is to make the dominance tree consider the final icmp before it
 ; gets to simplify the purely constant one (%tst). Since that icmp uses the

llvm/test/Transforms/EarlyCSE/debug-info-undef.ll

-; RUN: opt -S %s -early-cse | FileCheck %s
+; RUN: opt -S %s -early-cse -earlycse-debug-hash | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 @a = global i8 25, align 1, !dbg !0
 
 define signext i16 @b() !dbg !12 {
 entry:
   call void @llvm.dbg.value(metadata i16 23680, metadata !17, metadata !DIExpression()), !dbg !18

llvm/test/Transforms/EarlyCSE/debuginfo-dce.ll

-; RUN: opt -early-cse -S %s -o - | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S %s -o - | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind uwtable
 define i32 @foo() !dbg !6 {
 entry:
   %0 = call i64 @llvm.ctpop.i64(i64 0), !dbg !14
   %1 = inttoptr i64 %0 to i32*, !dbg !14
   call void @llvm.dbg.value(metadata i32* %1, i64 0, metadata !11, metadata !13), !dbg !14

llvm/test/Transforms/EarlyCSE/edge.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 ; Same as GVN/edge.ll, but updated to reflect EarlyCSE's less powerful
 ; implementation.  EarlyCSE currently doesn't exploit equality comparisons
 ; against constants.
 
 define i32 @f1(i32 %x) {
   ; CHECK-LABEL: define i32 @f1(
 bb0:

llvm/test/Transforms/EarlyCSE/fence.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
 ; NOTE: This file is testing the current implementation.  Some of
 ; the transforms used as negative tests below would be legal, but 
 ; only if reached through a chain of logic which EarlyCSE is incapable
 ; of performing.  To say it differently, this file tests a conservative
 ; version of the memory model.  If we want to extend EarlyCSE to be more
 ; aggressive in the future, we may need to relax some of the negative tests.
 

llvm/test/Transforms/EarlyCSE/flags.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 
 declare void @use(i1)
 
 define void @test1(float %x, float %y) {
 entry:
   %cmp1 = fcmp nnan oeq float %y, %x
   %cmp2 = fcmp oeq float %x, %y

llvm/test/Transforms/EarlyCSE/floatingpoint.ll

-; RUN: opt < %s -S -early-cse | FileCheck %s
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
 
 ; Ensure we don't simplify away additions vectors of +0.0's (same as scalars).
 define <4 x float> @fV( <4 x float> %a) {
        ; CHECK: %b = fadd <4 x float> %a, zeroinitializer
        %b = fadd  <4 x float> %a, <float 0.0,float 0.0,float 0.0,float 0.0>
        ret <4 x float> %b
 }

llvm/test/Transforms/EarlyCSE/gc_relocate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 
 declare void @func()
 declare i32 @"personality_function"()
 
 define i1 @test_call(i32 addrspace(1)* %in) gc "statepoint-example" {
 ; CHECK-LABEL: @test_call(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SAFEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @func, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i32 addrspace(1)* [[IN:%.*]], i32 addrspace(1)* [[IN]]) ]

llvm/test/Transforms/EarlyCSE/globalsaa-memoryssa.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -S -globals-aa -early-cse-memssa | FileCheck %s
+; RUN: opt < %s -S -globals-aa -early-cse-memssa -earlycse-debug-hash | FileCheck %s
 
 define i16 @f1() readonly {
   ret i16 0
 }
 
 declare void @f2()
 
 ; Check that EarlyCSE correctly handles function calls that don't have

llvm/test/Transforms/EarlyCSE/guards.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa --enable-knowledge-retention | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
 
 declare void @llvm.experimental.guard(i1,...)
 
 declare void @llvm.assume(i1)
 
 define i32 @test0(i32* %ptr, i1 %cond) {

llvm/test/Transforms/EarlyCSE/instsimplify-dom.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 ; PR12231
 
 declare i32 @f()
 
 define i32 @fn() {
 entry:
   br label %lbl_1215

llvm/test/Transforms/EarlyCSE/int_sideeffect.ll

-; RUN: opt -S < %s -early-cse | FileCheck %s
+; RUN: opt -S < %s -early-cse -earlycse-debug-hash | FileCheck %s
 
 declare void @llvm.sideeffect()
 
 ; Store-to-load forwarding across a @llvm.sideeffect.
 
 ; CHECK-LABEL: s2l
 ; CHECK-NOT: load
 define float @s2l(float* %p) {

llvm/test/Transforms/EarlyCSE/invariant-loads.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 ; RUN: opt -S -basic-aa -early-cse-memssa < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 ; RUN: opt -S -basic-aa -early-cse-memssa --enable-knowledge-retention < %s | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
 
 declare void @clobber_and_use(i32)
 
 define void @f_0(i32* %ptr) {
 ; NO_ASSUME-LABEL: @f_0(
 ; NO_ASSUME-NEXT:    [[VAL0:%.*]] = load i32, i32* [[PTR:%.*]], align 4, !invariant.load !0

llvm/test/Transforms/EarlyCSE/invariant.start.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt < %s -S -early-cse | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 ; RUN: opt < %s -S -early-cse --enable-knowledge-retention | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
 ; RUN: opt < %s -S -passes=early-cse | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
 
 declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture) nounwind readonly
 declare void @llvm.invariant.end.p0i8({}*, i64, i8* nocapture) nounwind
 
 ; Check that we do load-load forwarding over invariant.start, since it does not
 ; clobber memory

llvm/test/Transforms/EarlyCSE/memoryssa.ll

-; RUN: opt < %s -S -early-cse | FileCheck %s --check-prefix=CHECK-NOMEMSSA
+; RUN: opt < %s -S -early-cse -earlycse-debug-hash | FileCheck %s --check-prefix=CHECK-NOMEMSSA
 ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s
 ; RUN: opt < %s -S -passes='early-cse' | FileCheck %s --check-prefix=CHECK-NOMEMSSA
 ; RUN: opt < %s -S -aa-pipeline=basic-aa -passes='early-cse-memssa' | FileCheck %s
 
 @G1 = global i32 zeroinitializer
 @G2 = global i32 zeroinitializer
 @G3 = global i32 zeroinitializer
 

llvm/test/Transforms/EarlyCSE/phi.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt           -early-cse        -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 ; RUN: opt -basic-aa -early-cse-memssa -S < %s | FileCheck %s
 
 ; Most basic case, fully identical PHI nodes
 define void @test0(i32 %v0, i32 %v1, i1 %c, i32* %d0, i32* %d1) {
 ; CHECK-LABEL: @test0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[B0:%.*]], label [[B1:%.*]]
 ; CHECK:       b0:

llvm/test/Transforms/EarlyCSE/pr33406.ll

-; RUN: opt -early-cse-memssa -S %s | FileCheck %s
+; RUN: opt -early-cse-memssa -earlycse-debug-hash -S %s | FileCheck %s
 
 ; CHECK: define void @patatino() {
 ; CHECK:  for.cond:
 ; CHECK-NEXT:  br i1 true, label %if.end, label %for.inc
 ; CHECK:  if.end:
 ; CHECK-NEXT:  %tinkywinky = load i32, i32* @b
 ; CHECK-NEXT:  br i1 true, label %for.inc, label %for.inc
 ; CHECK:  for.inc:

llvm/test/Transforms/EarlyCSE/readnone-mayunwind.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 declare void @readnone_may_unwind() readnone
 
 define void @f(i32* %ptr) {
 ; CHECK-LABEL: @f(
 ; CHECK: store i32 100, i32* %ptr
 ; CHECK: call void @readnone_may_unwind()
 ; CHECK: store i32 200, i32* %ptr
 
   store i32 100, i32* %ptr
   call void @readnone_may_unwind()
   store i32 200, i32* %ptr
   ret void
 }

llvm/test/Transforms/EarlyCSE/writeonly.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 @var = global i32 undef
 declare void @foo() nounwind
 
 define void @test() {
 ; CHECK-LABEL: @test(
 ; CHECK-NOT: store
   store i32 1, i32* @var
 ; CHECK: call void @foo()
   call void @foo() writeonly
 ; CHECK: store i32 2, i32* @var
   store i32 2, i32* @var
   ret void
 }

llvm/test/Transforms/GVNHoist/pr37445.ll

-; RUN: opt < %s -early-cse-memssa -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -early-cse-memssa -earlycse-debug-hash -gvn-hoist -S | FileCheck %s
 
 ; Make sure opt won't crash and that this pair of
 ; instructions (load, icmp) is hoisted successfully
 ; from bb45 and bb58 to bb41.
 
 @g_10 = external global i32, align 4
 @g_536 = external global i8*, align 8
 @g_1629 = external global i32**, align 8

llvm/test/Transforms/GVNHoist/pr38807.ll

-; RUN: opt < %s -early-cse-memssa -gvn-hoist -S | FileCheck %s
+; RUN: opt < %s -early-cse-memssa -earlycse-debug-hash -gvn-hoist -S | FileCheck %s
 
 ; Make sure opt doesn't crash. On top of that, the instructions
 ; of the side blocks should be hoisted to the entry block.
 
 %s = type { i32, i64 }
 %S = type { %s, i32 }
 
 ;CHECK-LABEL: @foo

llvm/test/Transforms/Inline/inline-indirect-chain.ll

-; RUN: opt -inline -early-cse < %s
+; RUN: opt -inline -early-cse -earlycse-debug-hash < %s
 ; This test used to crash (PR35469).
 
 define void @func1() {
   %t = bitcast void ()* @func2 to void ()*
   tail call void %t()
   ret void
 }
 

llvm/test/Transforms/InstCombine/invariant.group.ll

-; RUN: opt -instcombine -early-cse -S < %s | FileCheck %s
+; RUN: opt -instcombine -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 
 
 ; CHECK-LABEL: define i8* @simplifyNullLaunder()
 define i8* @simplifyNullLaunder() {
 ; CHECK-NEXT: ret i8* null
   %b2 = call i8* @llvm.launder.invariant.group.p0i8(i8* null)
   ret i8* %b2
 }

llvm/test/Transforms/InstSimplify/ConstProp/allones.ll

-; RUN: opt -early-cse -S -o - %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S -o - %s | FileCheck %s
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64-ni:2"
 target triple = "armv7-unknown-linux-gnueabi"
 
 %struct.anon = type { i32 }
 
 @onesstruct = private constant %struct.anon { i32 -1 }, align 4
 
 define i32 @allones_struct() {

llvm/test/Transforms/InstSimplify/ConstProp/math-1.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -early-cse -S -o - %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S -o - %s | FileCheck %s
 
 declare double @acos(double)
 define double @f_acos() {
 ; CHECK-LABEL: @f_acos(
 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %res = tail call fast double @acos(double 1.0)
   ret double %res

llvm/test/Transforms/InstSimplify/ConstProp/math-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -early-cse -S -o - %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S -o - %s | FileCheck %s
 
 declare double @atan2(double, double)
 define double @f_atan2() {
 ; CHECK-LABEL: @f_atan2(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan2(double 1.000000e+00, double 2.000000e+00)
 ; CHECK-NEXT:    ret double 0x3FDDAC6{{.+}}
 ;
   %res = tail call fast double @atan2(double 1.0, double 2.0)

llvm/test/Transforms/InstSimplify/ConstProp/rint.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 declare float @nearbyintf(float) #0
 declare float @llvm.nearbyint.f32(float) #0
 declare double @nearbyint(double) #0
 declare double @llvm.nearbyint.f64(double) #0
 declare float @rintf(float) #0
 declare float @llvm.rint.f32(float) #0
 declare double @rint(double) #0

llvm/test/Transforms/InstSimplify/ConstProp/round.ll

-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 declare float @roundf(float) #0
 declare float @llvm.round.f32(float) #0
 declare double @round(double) #0
 declare double @llvm.round.f64(double) #0
 
 ; CHECK-LABEL: @constant_fold_round_f32_01
 ; CHECK-NEXT: ret float 1.000000e+00

llvm/test/Transforms/InstSimplify/ConstProp/trunc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s
+; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s
 
 declare float @truncf(float) #0
 declare float @llvm.trunc.f32(float) #0
 declare double @trunc(double) #0
 declare double @llvm.trunc.f64(double) #0
 
 define float @constant_fold_trunc_f32_01() #0 {
 ; CHECK-LABEL: @constant_fold_trunc_f32_01(

llvm/test/Transforms/InstSimplify/ConstProp/vscale-getelementptr.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64"
 
 ; CHECK-LABEL: define <4 x i32*> @fixed_length_version_first() {
 ; CHECK-NEXT:  ret <4 x i32*> undef
 define <4 x i32*> @fixed_length_version_first() {
   %ptr = getelementptr i32, <4 x i32*> undef, <4 x i64> undef

llvm/test/Transforms/InstSimplify/ConstProp/vscale-shufflevector.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
+; RUN: opt -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64"
 
 ; This test checks that SimplifyInstruction does not blow up in the face of
 ; a scalable shufflevector. vscale is a constant value known only at runtime.
 ; Therefore, it is not possible to know the concrete value of, or the length
 ; of the mask at compile time. Simplifications that depend on the value

llvm/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll

-; RUN: opt < %s -nary-reassociate -early-cse -S | FileCheck %s
+; RUN: opt < %s -nary-reassociate -early-cse -earlycse-debug-hash -S | FileCheck %s
 ; RUN: opt < %s -passes='nary-reassociate' -S | opt -early-cse -S | FileCheck %s
 
 target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64"
 target triple = "nvptx64-unknown-unknown"
 
 declare void @foo(float*)
 
 ; foo(&a[i]);

llvm/test/Transforms/Reassociate/cse-pairs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -reassociate -early-cse -S < %s | FileCheck %s
+; RUN: opt -reassociate -early-cse -earlycse-debug-hash -S < %s | FileCheck %s
 
 @num1 = local_unnamed_addr global i32 0, align 4
 @num2 = local_unnamed_addr global i32 0, align 4
 @num3 = local_unnamed_addr global i32 0, align 4
 @num4 = local_unnamed_addr global i32 0, align 4
 
 define signext i32 @twoPairs(i32 signext %0, i32 signext %1, i32 signext %2, i32 signext %3, i32 signext %4) {
 ; CHECK-LABEL: @twoPairs(