[Test] Fix CHECK typo.

[zequanwu]

Fix more typos.

[probinson]

Nice work!
have you verified that all the modified tests pass? naively it looks like you'd need at least 3 different targets to run them all (windows, webassembly, powerpc)

[zequanwu]

In D137287#3905474, @probinson wrote:

Nice work!
have you verified that all the modified tests pass? naively it looks like you'd need at least 3 different targets to run them all (windows, webassembly, powerpc)

Those are target independent tests. I'm able to run and pass those tests in my linux machine.

[probinson]

LGTM, but you'll want to be ready to jump on any bot failures. That's just the nature of these kinds of changes.

clang-tools-extra/test/clang-apply-replacements/Inputs/ignore-conflict/ignore-conflict.cpp

 class MyType {};
 // CHECK: #include <a.h>
 // CHECK-NEXT: #include <b.h>
-// CEHCK-NEXT: class MyType {};
+// CHECK-NEXT: class MyType {};

clang/test/CodeGenCoroutines/pr56329.cpp

 }
 
 // CHECK: define{{.*}}@_Z5Outerv.resume(
 // CHECK-NOT: }
 // CHECK-NOT: _exit
 // CHECK: musttail call
 // CHECK: musttail call
 // CHECK-NEXT: ret void
-// CHEKC-NEXT: }
+// CHECK-NEXT: }

clang/test/OpenMP/omp_with_loop_pragma_instr_profile.c

 }
 
 // CHECK-LABEL: @.omp_outlined.(
 // CHECK-NEXT:  entry:
 // CHECK:         call void @llvm.instrprof.increment(
 // CHECK:       omp.precond.then:
 // CHECK-NEXT:    call void @llvm.instrprof.increment(
 // CHECK:       cond.true:
-// CEHCK-NEXT:    call void @llvm.instrprof.increment(
+// CHECK-NEXT:    call void @llvm.instrprof.increment(
 // CHECK:       omp.inner.for.body:
 // CHECK-NEXT:    call void @llvm.instrprof.increment(

clang/test/OpenMP/target_parallel_for_codegen.cpp

#pragma omp cancellation point for
   }
 
   long long k = get_val();
   #pragma omp target parallel for if(target: 0) linear(k : 3) schedule(dynamic)
   for (int i = 10; i > 1; i--) {
     a += 1;
   }
 
-  // CEHCK-32:    [[FPSIZEGEP]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 0
-  // CEHCK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPSIZEGEP]], ptr align 8 [[SIZET2]], i64 24, i1 false)
-  // CEHCK-32:    [[FPBPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 1
-  // CEHCK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPBPGEP]], ptr align 8 [[BPGEP]], i64 24, i1 false)
-  // CEHCK-32:    [[FPPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 2
-  // CEHCK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPPGEP]], ptr align 8 [[BCAST]], i64 24, i1 false)
-  // CEHCK-64:    [[FPBPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 0
-  // CEHCK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPBPGEP]], ptr align 8 [[BPGEP]], i64 24, i1 false)
-  // CEHCK-64:    [[FPPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 1
-  // CEHCK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPPGEP]], ptr align 8 [[BCAST]], i64 24, i1 false)
-  // CEHCK-64:    [[FPSIZEGEP]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 2
-  // CEHCK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPSIZEGEP]], ptr align 8 [[SIZET2]], i64 24, i1 false)
+  // CHECK-32:    [[FPSIZEGEP]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 0
+  // CHECK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPSIZEGEP]], ptr align 8 [[SIZET2]], i64 24, i1 false)
+  // CHECK-32:    [[FPBPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 1
+  // CHECK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPBPGEP]], ptr align 8 [[BPGEP]], i64 24, i1 false)
+  // CHECK-32:    [[FPPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 2
+  // CHECK-32:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPPGEP]], ptr align 8 [[BCAST]], i64 24, i1 false)
+  // CHECK-64:    [[FPBPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 0
+  // CHECK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPBPGEP]], ptr align 8 [[BPGEP]], i64 24, i1 false)
+  // CHECK-64:    [[FPPGEP:%.+]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 1
+  // CHECK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPPGEP]], ptr align 8 [[BCAST]], i64 24, i1 false)
+  // CHECK-64:    [[FPSIZEGEP]] = getelementptr inbounds [[KMP_PRIVATES_T]], ptr [[KMP_PRIVATES]], i32 0, i32 2
+  // CHECK-64:    call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[FPSIZEGEP]], ptr align 8 [[SIZET2]], i64 24, i1 false)
   int lin = 12;
   #pragma omp target parallel for if(target: 1) linear(lin, a : get_val()) nowait
   for (unsigned long long it = 2000; it >= 600; it-=400) {
     aa += 1;
   }
 
 
 

flang/test/Lower/ext-proc-as-actual-argument-1.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
 
 ! Test external procedure as actual argument with the implicit character type.
 
 ! CHECK-LABEL: func @_QQmain
 ! CHECK:  %[[VAL_0:.*]] = fir.address_of(@_QPext_func) : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
 ! CHECK:  %[[VAL_1:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
 ! CHECK:  %[[VAL_2:.*]] = fir.undefined i64
 ! CHECK:  %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  fir.call @_QFPsub(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
 ! CHECK:  return
 
 ! CHECK-LABEL: func @_QPext_func(
-! CEHCK: %[[ARG_0:.*]]: !fir.ref<!fir.char<1,?>>, %[[ARG_1:.*]]: index) -> !fir.boxchar<1> {
+! CHECK: %[[ARG_0:.*]]: !fir.ref<!fir.char<1,?>>, %[[ARG_1:.*]]: index) -> !fir.boxchar<1> {
 program m
   external :: ext_func
   call sub(ext_func)
 
 contains
   subroutine sub(arg)
     character(20), external :: arg
     print *, arg()
   end
 end
 
 function ext_func() result(res)
   character(*) res
   res = "hello world"
 end

flang/test/Lower/ext-proc-as-actual-argument-2.f90

 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
 
 ! Test external procedure as actual argument with the implicit character type.
 
 ! CHECK-LABEL: func @_QQmain
 ! CHECK:  %[[VAL_0:.*]] = fir.address_of(@_QPext_func) : (!fir.ref<!fir.char<1,20>>, index) -> !fir.boxchar<1>
 ! CHECK:  %[[VAL_1:.*]] = fir.emboxproc %[[VAL_0]] : ((!fir.ref<!fir.char<1,20>>, index) -> !fir.boxchar<1>) -> !fir.boxproc<() -> ()>
 ! CHECK:  %[[VAL_2:.*]] = fir.undefined i64
 ! CHECK:  %[[VAL_3:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  %[[VAL_4:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_1]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  %[[VAL_5:.*]] = fir.insert_value %[[VAL_4]], %[[VAL_2]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:  fir.call @_QFPsub(%[[VAL_5]]) : (tuple<!fir.boxproc<() -> ()>, i64>) -> ()
 ! CHECK:  return
 
 ! CHECK-LABEL: func @_QPext_func(
-! CEHCK: %[[ARG_0:.*]]: !fir.ref<!fir.char<1,20>>, %[[ARG_1:.*]]: index) -> !fir.boxchar<1> {
+! CHECK: %[[ARG_0:.*]]: !fir.ref<!fir.char<1,20>>, %[[ARG_1:.*]]: index) -> !fir.boxchar<1> {
 program m
   external :: ext_func
   call sub(ext_func)
 
 contains
   subroutine sub(arg)
     character(20), external :: arg
     print *, arg()
   end
 end
 
 function ext_func() result(res)
   character(20) res
   res = "hello world"
 end

flang/test/Lower/fail_image.f90

 ! RUN: bbc -emit-fir -o - %s | FileCheck %s
 ! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPfail_image_test
 subroutine fail_image_test(fail)
   logical :: fail
 ! CHECK:  cond_br {{.*}}, ^[[BB1:.*]], ^[[BB2:.*]]
 ! CHECK: ^[[BB1]]:
   if (fail) then
 ! CHECK:  {{.*}} = fir.call @_FortranAFailImageStatement() : () -> none
 ! CHECK-NEXT:  fir.unreachable
    FAIL IMAGE
   end if
 ! CHECK: ^[[BB2]]:
 ! CHECK-NEXT:  br ^[[BB3:.*]]
 ! CHECK-NEXT: ^[[BB3]]
-! CEHCK-NEXT:  return
+! CHECK-NEXT:  return
   return
 end subroutine
 ! CHECK-LABEL: func private @_FortranAFailImageStatement() -> none attributes {fir.runtime}

lldb/test/Shell/SymbolFile/NativePDB/inline_sites.test

 #CHECK: Breakpoint 12: where = {{.*}}`main + 57 at a.cpp:3, address = 0x0000000140001039
 #CHECK: (lldb) b a.cpp:4
 #CHECK: Breakpoint 13: where = {{.*}}`main + 61 at a.cpp:4, address = 0x000000014000103d
 
 # FIXME: The following variable location have wrong register numbers due to
 # https://github.com/llvm/llvm-project/issues/53575. Fix them after resolving
 # the issue.
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x140001003 -v
+# CHECK-LABEL: (lldb) image lookup -a 0x140001003 -v
 # CHECK:       Summary: {{.*}}`main + 3 at a.cpp:2
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:       Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK:       LineEntry: [0x0000000140001000-0x0000000140001004): /tmp/a.cpp:2
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argc", type = "int", valid ranges = <block>, location = [0x0000000140001000, 0x000000014000102d) -> DW_OP_reg26 XMM9
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x140001004 -v
+# CHECK-LABEL: (lldb) image lookup -a 0x140001004 -v
 # CHECK:       Summary: {{.*}}`main + 4 [inlined] Namespace1::foo at a.h:5
 # CHECK-NEXT:           {{.*}}`main + 4 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK-NEXT:            id = {{.*}}, ranges = [0x140001004-0x140001039)[0x14000103f-0x140001046), name = "Namespace1::foo", decl = a.h:4
 # CHECK:       LineEntry: [0x0000000140001004-0x000000014000100c): /tmp/a.h:5
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = <empty>, decl =
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "foo_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001039) -> DW_OP_breg7 RSP+44
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argc", type = "int", valid ranges = <block>, location = [0x0000000140001000, 0x000000014000102d) -> DW_OP_reg26 XMM9
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "main_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001046) -> DW_OP_breg7 RSP+48
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x140001010 -v
+# CHECK-LABEL: (lldb) image lookup -a 0x140001010 -v
 # CHECK:       Summary: {{.*}}`main + 16 [inlined] Namespace1::foo + 12 at a.h:7
 # CHECK-NEXT:           {{.*}}`main + 4 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK-NEXT:            id = {{.*}}, ranges = [0x140001004-0x140001039)[0x14000103f-0x140001046), name = "Namespace1::foo", decl = a.h:4
 # CHECK:       LineEntry: [0x0000000140001010-0x0000000140001018): /tmp/a.h:7
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = <empty>, decl =
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "foo_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001039) -> DW_OP_breg7 RSP+44
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argc", type = "int", valid ranges = <block>, location = [0x0000000140001000, 0x000000014000102d) -> DW_OP_reg26 XMM9
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "main_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001046) -> DW_OP_breg7 RSP+48
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x14000101c -v
+# CHECK-LABEL: (lldb) image lookup -a 0x14000101c -v
 # CHECK:       Summary: {{.*}}`main + 28 [inlined] Class1::bar at b.h:5
 # CHECK-NEXT:           {{.*}}`main + 28 [inlined] Namespace1::foo + 24 at a.h:9
 # CHECK-NEXT:           {{.*}}`main + 4 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK-NEXT:            id = {{.*}}, ranges = [0x140001004-0x140001039)[0x14000103f-0x140001046), name = "Namespace1::foo", decl = a.h:4
 # CHECK-NEXT:            id = {{.*}}, range = [0x14000101c-0x140001039), name = "Class1::bar", decl = b.h:4
 # CHECK:       LineEntry: [0x000000014000101c-0x0000000140001022): /tmp/b.h:5
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = [0x000000014000101c, 0x000000014000101e) -> DW_OP_reg24 XMM7
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "bar_local", type = "int", valid ranges = <block>, location = [0x000000014000101c, 0x0000000140001039) -> DW_OP_breg7 RSP+52
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = <empty>, decl =
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "foo_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001039) -> DW_OP_breg7 RSP+44
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argc", type = "int", valid ranges = <block>, location = [0x0000000140001000, 0x000000014000102d) -> DW_OP_reg26 XMM9
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "main_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001046) -> DW_OP_breg7 RSP+48
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x14000102a -v
+# CHECK-LABEL: (lldb) image lookup -a 0x14000102a -v
 # CHECK:       Summary: {{.*}}`main + 42 [inlined] Namespace2::Class2::func at c.h:5
 # CHECK-NEXT:           {{.*}}`main + 42 [inlined] Class1::bar + 14 at b.h:7
 # CHECK-NEXT:           {{.*}}`main + 28 [inlined] Namespace1::foo + 24 at a.h:9
 # CHECK-NEXT:           {{.*}}`main + 4 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK-NEXT:            id = {{.*}}, ranges = [0x140001004-0x140001039)[0x14000103f-0x140001046), name = "Namespace1::foo", decl = a.h:4
 # CHECK-NEXT:            id = {{.*}}, range = [0x14000101c-0x140001039), name = "Class1::bar", decl = b.h:4
 # CHECK-NEXT:            id = {{.*}}, range = [0x14000102a-0x140001039), name = "Namespace2::Class2::func", decl = c.h:4
 # CHECK:       LineEntry: [0x000000014000102a-0x0000000140001031): /tmp/c.h:5
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = [0x000000014000102a, 0x0000000140001039) -> DW_OP_reg24 XMM7
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "func_local", type = "int", valid ranges = <block>, location = [0x000000014000102a, 0x0000000140001039) -> DW_OP_breg7 RSP+48
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "bar_local", type = "int", valid ranges = <block>, location = [0x000000014000101c, 0x0000000140001039) -> DW_OP_breg7 RSP+52
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = <empty>, decl =
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "foo_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001039) -> DW_OP_breg7 RSP+44
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argc", type = "int", valid ranges = <block>, location = [0x0000000140001000, 0x000000014000102d) -> DW_OP_reg26 XMM9
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "main_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001046) -> DW_OP_breg7 RSP+48
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x140001039 -v
+# CHECK-LABEL: (lldb) image lookup -a 0x140001039 -v
 # CHECK:       Summary: {{.*}}`main + 57 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK:       LineEntry: [0x0000000140001039-0x000000014000103d): /tmp/a.cpp:3
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "argv", type = "char **", valid ranges = <block>, location = [0x0000000140001000, 0x0000000140001045) -> DW_OP_reg3 RBX
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "main_local", type = "int", valid ranges = <block>, location = [0x0000000140001004, 0x0000000140001046) -> DW_OP_breg7 RSP+48
 
-# CEHCK-LABEL: (lldb) image lookup -a 0x140001044 -v
+# CHECK-LABEL: (lldb) image lookup -a 0x140001044 -v
 # CHECK:       Summary: {{.*}}`main + 68 [inlined] Namespace1::foo + 5 at a.h:8
 # CHECK-NEXT:           {{.*}}`main + 63 at a.cpp:3
 # CHECK:       Function: id = {{.*}}, name = "main", range = [0x0000000140001000-0x0000000140001046)
 # CHECK:         Blocks: id = {{.*}}, range = [0x140001000-0x140001046)
 # CHECK-NEXT:            id = {{.*}}, ranges = [0x140001004-0x140001039)[0x14000103f-0x140001046), name = "Namespace1::foo", decl = a.h:4
 # CHECK:       LineEntry: [0x0000000140001044-0x0000000140001046): /tmp/a.h:8
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "x", type = "int", valid ranges = <block>, location = <empty>, decl =
 # CHECK-NEXT:  Variable: id = {{.*}}, name = "foo_local", type = "int", valid ranges = <block>, location = [0x0000000140001044, 0x0000000140001046) -> DW_OP_breg7 RSP+44

llvm/test/CodeGen/PowerPC/livevars-crash2.mir

body:             |
   ; CHECK:   %12:g8rc_and_g8rc_nox0 = COPY killed %0
 
   ; CHECK: bb.1.loop:
   ; CHECK:   successors: %bb.1(0x20000000), %bb.2(0x60000000)
 
   ; CHECK:   %1:g8rc_and_g8rc_nox0 = COPY killed %12
   ; CHECK:   %5:gprc = LBZ 0, %1 :: (load (s8) from %ir.0)
   ; CHECK:   %6:crrc = CMPWI killed %5, 0
-  ; CEHCK:   %7:crbitrc = COPY killed %6.sub_eq
+  ; CHECK:   %7:crbitrc = COPY killed %6.sub_eq
   ; CHECK:   %2:g8rc = nuw ADDI8 %1, 1
   ; CHECK:   STD %2, 0, %4 :: (store (s64) into %ir.p)
   ; CHECK:   %8:gprc = LBZ 1, %1 :: (load (s8) from %ir.incdec.ptr)
   ; CHECK:   %12:g8rc_and_g8rc_nox0 = COPY %2
   ; CHECK:   BCn killed %7, %bb.1
   ; CHECK:   B %bb.2
 
   ; CHECK: bb.2.loop:

llvm/test/CodeGen/PowerPC/phi-eliminate.mir

body:             |
   ; CHECK:   B %bb.5
 
   ; CHECK: bb.2 (%ir-block.4):
   ; CHECK:   successors: %bb.3(0x40000000), %bb.4(0x40000000)
   ; CHECK:   %20:gprc = nsw MULLW %19, %9
   ; CHECK:   %21:gprc = SUBF killed %20, killed %8
   ; CHECK:   %22:crrc = CMPLWI %21, 10
   ; CHECK:   %23:gprc = ISEL %15, %14, killed %22.sub_lt
-  ; CEHCK:   %24:gprc = ADD4 killed %23, killed %21
+  ; CHECK:   %24:gprc = ADD4 killed %23, killed %21
   ; CHECK:   %25:g8rc_and_g8rc_nox0 = STBU killed %24, -1, undef %0:g8rc_and_g8rc_nox0 :: (store (s8) into %ir.7)
   ; CHECK:   %26:gprc = DIVW %19, %9
   ; CHECK:   %57:gprc = COPY killed %26
   ; CHECK:   %58:gprc = COPY %19
   ; CHECK:   %59:g8rc_and_g8rc_nox0 = COPY killed %25
   ; CHECK:   %60:gprc = COPY killed %19
   ; CHECK:   BDZ8 %bb.4, implicit-def $ctr8, implicit $ctr8
   ; CHECK:   B %bb.3

llvm/test/CodeGen/PowerPC/vsx-args.ll

 ; CHECK: xvadddp 34, 34, [[VC]]
 ; CHECK: blr
 
 ; CHECK-FISL-LABEL: @main
 ; CHECK-FISL: stxvd2x 36, 1, 3
 ; CHECK-FISL: vmr 4, 3
 ; CHECK-FISL: lxvd2x 35, 1, 3
 ; CHECK-FISL: 3, 144
-; CHCEK-FISL: stxvd2x 36, 1, 3
+; CHECK-FISL: stxvd2x 36, 1, 3
 ; CHECK-FISL: vmr 4, 2
 ; CHECK-FISL: bl sv
 
 ; CHECK-FISL: lxvd2x [[VC:[0-9]+]],
 ; CHECK-FISL: xvadddp 34, 34, [[VC]]
 ; CHECK-FISL: blr
 }
 
 attributes #0 = { noinline nounwind readnone }
 attributes #1 = { nounwind }

llvm/test/DebugInfo/MIR/InstrRef/pick-vphi-in-shifting-loop.mir

 # CHECK-LABEL: bb.3:
 # CHECK:       DBG_INSTR_REF 7, 0
 # CHECK-NEXT:  DBG_VALUE $rdx
 # CHECK-NEXT:  $rcx = MOV64rr $rdx
 # CHECK-LABEL: bb.4:
 # CHECK:       DBG_VALUE $rcx
 # CHECK-NEXT:  $rdx = MOV64rr killed $rcx
 # CHECK-LABEL: bb.5:
-# CHEKC-NOT:   DBG_VALUE
+# CHECK-NOT:   DBG_VALUE
 --- |
   target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
   
   ; Function Attrs: nofree norecurse nosync nounwind readonly uwtable
   define dso_local void @bees() local_unnamed_addr !dbg !13 {
   entry:
     ret void, !dbg !22

llvm/test/MC/WebAssembly/tag-section-decoding.ll

define i32 @test_throw(i8* %p) {
   ret i32 0
 }
 
 ; Checks to see if the tag index is correctly decoded in ULEB128. If it is
 ; decoded with LEB128, 64 will not be correctly decoded. 64 is the smallest
 ; number with which its LEB128 and ULEB128 encodings are different, because its
 ; 7th least significant bit is not 0.
 ; CHECK:      - Type:            TAG
-; CHEC-NEXT:    TagTypes:        [ 64 ]
+; CHECK-NEXT:    TagTypes:        [ 64 ]

llvm/test/MC/WebAssembly/type-checker-emit-after-unreachable.s

if i32
     i32.const 2
     return
   else
     i32.const 3
   end_if
   end_function
 
 # CHECK-LABEL: foo:
-# CHEKC-NEXT: .functype foo () -> (i32)
-# CHEKC-NEXT: i32.const 1
-# CHEKC-NEXT: if i32
-# CHEKC-NEXT: i32.const 2
-# CHEKC-NEXT: return
-# CHEKC-NEXT: else
-# CHEKC-NEXT: i32.const 3
-# CHEKC-NEXT: end_if
-# CHEKC-NEXT: end_function
+# CHECK-NEXT: .functype foo () -> (i32)
+# CHECK-NEXT: i32.const 1
+# CHECK-NEXT: if i32
+# CHECK-NEXT: i32.const 2
+# CHECK-NEXT: return
+# CHECK-NEXT: else
+# CHECK-NEXT: i32.const 3
+# CHECK-NEXT: end_if
+# CHECK-NEXT: end_function

llvm/test/Transforms/Coroutines/coro-debug.ll

 ; Note that keeping the undef value here could be acceptable, too.
 ; CHECK-NOT: call void @llvm.dbg.declare(metadata i32* undef, metadata !{{[0-9]+}}, metadata !DIExpression())
 ; CHECK: call void @coro.devirt.trigger(i8* null)
 ; CHECK: call void @llvm.dbg.value(metadata %f.Frame** {{.*}}, metadata ![[RESUME_DIRECT_VALUE:[0-9]+]], metadata !DIExpression(DW_OP_deref, DW_OP_plus_uconst, {{[0-9]+}}, DW_OP_deref))
 ; Check that the dbg.declare intrinsic of invoke instruction is hanled correctly.
 ; CHECK: %[[ALLOCATED_STORAGE:.+]] = invoke i8* @allocate()
 ; CHECK-NEXT: to label %[[NORMAL_DEST:.+]] unwind
 ; CHECK: [[NORMAL_DEST]]
-; CHEKC-NEXT: call void @llvm.dbg.declare(metadata i8* %[[ALLOCATED_STORAGE]]
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata i8* %[[ALLOCATED_STORAGE]]
 ; CHECK: %[[CALLBR_RES:.+]] = callbr i32 asm
 ; CHECK-NEXT: to label %[[DEFAULT_DEST:.+]] [label
 ; CHECK: [[DEFAULT_DEST]]:
 ; CHECK-NEXT: call void @llvm.dbg.declare(metadata i32 %[[CALLBR_RES]]
 ; CHECK: define internal fastcc void @f.destroy(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[DESTROY:[0-9]+]]
 ; CHECK: define internal fastcc void @f.cleanup(%f.Frame* noalias nonnull align 8 dereferenceable(40) %FramePtr) #0 personality i32 0 !dbg ![[CLEANUP:[0-9]+]]
 
 ; CHECK: ![[ORIG]] = distinct !DISubprogram(name: "f", linkageName: "flink"

llvm/test/tools/llvm-profgen/recursion-compression-pseudoprobe.test

 ; CHECK-MAX-CTX-DEPTH:  8: 1 fa:1
 ; CHECK-MAX-CTX-DEPTH:  !CFGChecksum: 563070469352221
 
 
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb]:13:4
 ; CHECK:  1: 4
 ; CHECK:  2: 3
 ; CHECK:  3: 1
-; CEHCK:  5: 4 fb:4
+; CHECK:  5: 4 fb:4
 ; CHECK:  6: 1 fa:1
 ; CHECK !CFGChecksum: 563022570642068
 ; CHECK: [main:2 @ foo:5 @ fa:8 @ fa:7 @ fb:5 @ fb:6 @ fa:8 @ fa:7 @ fb:6 @ fa]:6:2
 ; CHECK:  1: 2
 ; CHECK:  3: 2
 ; CHECK:  4: 1
 ; CHECK:  7: 1 fb:1
 ; CHECK:  !CFGChecksum: 563070469352221

mlir/test/Conversion/MathToSPIRV/math-to-gl-spirv.mlir

func.func @powf_scalar(%lhs: f32, %rhs: f32) -> f32 {
   %0 = math.powf %lhs, %rhs : f32
   // CHECK: return %[[SEL]]
   return %0: f32
 }
 
 // CHECK-LABEL: @powf_vector
 func.func @powf_vector(%lhs: vector<4xf32>, %rhs: vector<4xf32>) -> vector<4xf32> {
   // CHECK: spirv.FOrdLessThan
-  // CHEKC: spirv.GL.FAbs
+  // CHECK: spirv.GL.FAbs
   // CHECK: spirv.GL.Pow %{{.*}}: vector<4xf32>
   // CHECK: spirv.FNegate
   // CHECK: spirv.Select
   %0 = math.powf %lhs, %rhs : vector<4xf32>
   return %0: vector<4xf32>
 }
 
 // CHECK-LABEL: @round_scalar

mlir/test/Dialect/MemRef/canonicalize.mlir

func.func @subview_canonicalize(%arg0 : memref<?x?x?xf32>, %arg1 : index,
   return %0 : memref<?x?x?xf32, strided<[?, ?, ?], offset: ?>>
 }
 // CHECK-LABEL: func @subview_canonicalize
 //  CHECK-SAME:   %[[ARG0:.+]]: memref<?x?x?xf32>
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[ARG0]][0, %{{[a-zA-Z0-9_]+}}, 1]
 //  CHECK-SAME:      [4, 1, %{{[a-zA-Z0-9_]+}}] [1, 1, 1]
 //  CHECK-SAME:      : memref<?x?x?xf32> to memref<4x1x?xf32
 //       CHECK:   %[[RESULT:.+]] = memref.cast %[[SUBVIEW]]
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 func.func @rank_reducing_subview_canonicalize(%arg0 : memref<?x?x?xf32>, %arg1 : index,
   %arg2 : index) -> memref<?x?xf32, strided<[?, 1], offset: ?>>
 {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index

mlir/test/Dialect/Tensor/canonicalize.mlir

func.func @slice_canonicalize(%arg0 : tensor<?x?x?xf32>, %arg1 : index,
   return %0 : tensor<?x?x?xf32>
 }
 // CHECK-LABEL: func @slice_canonicalize
 //  CHECK-SAME:   %[[ARG0:.+]]: tensor<?x?x?xf32>
 //       CHECK:   %[[SLICE:.+]] = tensor.extract_slice %[[ARG0]][0, %{{[a-zA-Z0-9_]+}}, 1]
 //  CHECK-SAME:      [4, 1, %{{[a-zA-Z0-9_]+}}] [1, 1, 1]
 //  CHECK-SAME:      : tensor<?x?x?xf32> to tensor<4x1x?xf32>
 //       CHECK:   %[[RESULT:.+]] = tensor.cast %[[SLICE]]
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 func.func @rank_reducing_slice_canonicalize(%arg0 : tensor<?x?x?xf32>, %arg1 : index,
     %arg2 : index) -> tensor<?x?xf32>
 {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c4 = arith.constant 4 : index
   %0 = tensor.extract_slice %arg0[%c0, %arg1, %c1] [%c4, 1, %arg2] [%c1, %c1, %c1] : tensor<?x?x?xf32> to tensor<?x?xf32>
   return %0 : tensor<?x?xf32>
 }
 // CHECK-LABEL: func @rank_reducing_slice_canonicalize
 //  CHECK-SAME:   %[[ARG0:.+]]: tensor<?x?x?xf32>
 //       CHECK:   %[[SLICE:.+]] = tensor.extract_slice %[[ARG0]][0, %{{[a-zA-Z0-9_]+}}, 1]
 //  CHECK-SAME:      [4, 1, %{{[a-zA-Z0-9_]+}}] [1, 1, 1]
 //  CHECK-SAME:      : tensor<?x?x?xf32> to tensor<4x?xf32>
 //       CHECK:   %[[RESULT:.+]] = tensor.cast %[[SLICE]]
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 // CHECK-LABEL: func @trivial_slice
 //  CHECK-SAME:   %[[ARG0:.[a-z0-9A-Z_]+]]: tensor<4x6x16x32xi8>
 //   CHECK-NOT:   tensor.extract_slice
 //       CHECK:   return %[[ARG0]] :  tensor<4x6x16x32xi8>
 func.func @trivial_slice(%arg0 : tensor<4x6x16x32xi8>) -> tensor<4x6x16x32xi8> {

 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
 //  CHECK-SAME:   %[[ARG3:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
 //       CHECK:   %[[SLICE:.+]] = tensor.extract_slice %[[ARG0]]
 //  CHECK-SAME:      [0, %{{.+}}, 1] [4, 1, %{{.+}} [1, 1, 1]
 //  CHECK-SAME:      : tensor<?x?x?xf32> to tensor<4x1x?xf32>
 //       CHECK:   %[[RESULT:.+]] = tensor.insert_slice %[[SLICE]]
 //  CHECK-SAME:      [0, %{{.+}}, 1] [4, 1, %{{.+}}] [1, 1, 1]
 //  CHECK-SAME:      : tensor<4x1x?xf32> into tensor<?x?x?xf32>
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 func.func @rank_reducing_insert_slice_canonicalize(%arg0 : tensor<?x?xf32>, %arg1 : index,
     %arg2 : index, %arg3 : tensor<?x?x?xf32>) -> tensor<?x?x?xf32>
 {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c4 = arith.constant 4 : index
   %0 = tensor.insert_slice %arg0 into %arg3[%c0, %arg1, %c1] [%c4, 1, %arg2] [%c1, %c1, %c1] : tensor<?x?xf32> into tensor<?x?x?xf32>
   return %0 : tensor<?x?x?xf32>
 }
 // CHECK-LABEL: func @rank_reducing_insert_slice_canonicalize
 //  CHECK-SAME:   %[[ARG0:.+]]: tensor<?x?xf32>
 //       CHECK:   %[[CAST:.*]] = tensor.cast %[[ARG0]] : tensor<?x?xf32> to tensor<4x?xf32>
 //       CHECK:   %[[RESULT:.+]] = tensor.insert_slice %[[CAST]]
 //  CHECK-SAME:      [0, %{{.+}}, 1] [4, 1, %{{.+}}] [1, 1, 1]
 //  CHECK-SAME:      : tensor<4x?xf32> into tensor<?x?x?xf32>
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 func.func @rank_reducing_slice_to_insert_slice_canonicalize(%arg0 : tensor<?x?x?xf32>, %arg1 : index,
     %arg2 : index, %arg3 : tensor<?x?x?xf32>) -> tensor<?x?x?xf32>
 {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c4 = arith.constant 4 : index
   %0 = tensor.extract_slice %arg0[%c0, %arg1, %c1] [%c4, 1, %arg2] [%c1, %c1, %c1] : tensor<?x?x?xf32> to tensor<?x?xf32>
   %1 = tensor.insert_slice %0 into %arg3[%c0, %arg1, %c1] [%c4, 1, %arg2] [%c1, %c1, %c1] : tensor<?x?xf32> into tensor<?x?x?xf32>
   return %1 : tensor<?x?x?xf32>
 }
 // CHECK-LABEL: func @rank_reducing_slice_to_insert_slice_canonicalize
 //  CHECK-SAME:   %[[ARG0:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
 //  CHECK-SAME:   %[[ARG3:[a-zA-Z0-9_]+]]: tensor<?x?x?xf32>
 //       CHECK:   %[[SLICE:.+]] = tensor.extract_slice %[[ARG0]]
 //  CHECK-SAME:     [0, %{{.+}}, 1] [4, 1, %{{.+}}] [1, 1, 1]
 //  CHECK-SAME:     : tensor<?x?x?xf32> to tensor<4x?xf32>
 //       CHECK:   %[[RESULT:.+]] = tensor.insert_slice %[[SLICE]] into %[[ARG3]]
 //  CHECK-SAME:      [0, %{{.+}}, 1] [4, 1, %{{.+}}] [1, 1, 1]
 //  CHECK-SAME:      : tensor<4x?xf32> into tensor<?x?x?xf32>
-//       CHEKC:   return %[[RESULT]]
+//       CHECK:   return %[[RESULT]]
 
 // -----
 
 func.func @insert_slice_propagate_dest_cast(%arg0 : tensor<2x?xi32>, %arg1 : tensor<i32>,
     %arg2 : index, %arg3 : index) -> tensor<?x?xi32> {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index

mlir/test/python/ir/affine_expr.py

with Context():
 
     # CHECK: 1
     print(s1.position)
     # CHECK: s1
     print(s1)
 
     # CHECK: 2
     print(s2.position)
-    # CHEKC: s2
+    # CHECK: s2
     print(s2)
 
     assert s1 == s11
     assert s1 != s2
 
 
 # CHECK-LABEL: TEST: testAffineAddExpr
 @run