[NFCI] Rerun update_test_checks.py on all Analysis tests

[jdoerfert]

Summary

NOTE: This is, for now, mostly to allow some discussion.

Rerun update_test_checks on all tests that have the 'Assertions have
been autogenerated by' line in llvm/test/Analysis except the ones below
that do have larger diffs for reasons not caused by D68819.

Exceptions:

llvm/test/Analysis/MustExecute/
llvm/test/Analysis/MemoryDependenceAnalysis/invariant.group-bug.ll

[nikic]

llvm/test/Analysis/ConstantFolding/math-1.ll

16

I guess a problem with doing these kinds of mass-regenerations is that it's easy to miss meaningful diffs that hide in between. Like this one -- I'm not sure why (presumably some host dependent float precision issue), but the use of {{.+}} here probably needs to be preserved.

[jdoerfert]

llvm/test/Analysis/ConstantFolding/math-1.ll

16

I think, at least for this diff, it is not hard to spot/identify any change that does not include define {{[^@]+}}. While that might not be always true, we can probably write decent filters for changes of this kind.

Wrt. this actual change, I see your point. Though, I think that it is more of a problem with our usage of this script (or, arguably, my intended usage).

On the one hand, the files "says" that check lines are auto generated but in reality they are not. If we cannot regenerate them, I'd say the NOTE is relatively useless. Maybe we don't need to rerun on this file ever again, then there is no need to mark the file with the NOTE. If the idea (of the note) is to tell people to run the update script when they change something, then it is unclear why we have manual changes like these that do not survive a rerun.
Maybe we shouldn't have such manual changes, so you see the actual diff. Maybe we should have manual changes that survive the update script.
Or maybe I misunderstand what the script and the NOTE is supposed to do.

[jdoerfert]

I came up with a partial solution for some of the problems here: D69701

Around manually modified parts you can now place markers that will prevent future changes, e.g.:

; UTC_ARGS: --turn off

// lines are copied

; UTC_ARGS: --turn on

[jdoerfert]

This was just for discussion anyway.

llvm/test/Analysis/ConstantFolding/bitcount.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 declare i31 @llvm.ctpop.i31(i31 %val)
 declare i32 @llvm.cttz.i32(i32 %val, i1)
 declare i33 @llvm.ctlz.i33(i33 %val, i1)
 declare <2 x i31> @llvm.ctpop.v2i31(<2 x i31> %val)
 declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> %val, i1)
 declare <2 x i33> @llvm.ctlz.v2i33(<2 x i33> %val, i1)
 
 define i31 @ctpop_const() {
-; CHECK-LABEL: @ctpop_const(
+; CHECK-LABEL: define {{[^@]+}}@ctpop_const(
 ; CHECK-NEXT:    ret i31 12
 ;
   %x = call i31 @llvm.ctpop.i31(i31 12415124)
   ret i31 %x
 }
 
 define i32 @cttz_const() {
-; CHECK-LABEL: @cttz_const(
+; CHECK-LABEL: define {{[^@]+}}@cttz_const(
 ; CHECK-NEXT:    ret i32 1
 ;
   %x = call i32 @llvm.cttz.i32(i32 87359874, i1 true)
   ret i32 %x
 }
 
 define i33 @ctlz_const() {
-; CHECK-LABEL: @ctlz_const(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_const(
 ; CHECK-NEXT:    ret i33 6
 ;
   %x = call i33 @llvm.ctlz.i33(i33 87359874, i1 true)
   ret i33 %x
 }
 
 define i31 @ctpop_zero() {
-; CHECK-LABEL: @ctpop_zero(
+; CHECK-LABEL: define {{[^@]+}}@ctpop_zero(
 ; CHECK-NEXT:    ret i31 0
 ;
   %x = call i31 @llvm.ctpop.i31(i31 0)
   ret i31 %x
 }
 
 define i32 @cttz_zero_defined() {
-; CHECK-LABEL: @cttz_zero_defined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_zero_defined(
 ; CHECK-NEXT:    ret i32 32
 ;
   %x = call i32 @llvm.cttz.i32(i32 0, i1 false)
   ret i32 %x
 }
 
 define i32 @cttz_zero_undefined() {
-; CHECK-LABEL: @cttz_zero_undefined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_zero_undefined(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %x = call i32 @llvm.cttz.i32(i32 0, i1 true)
   ret i32 %x
 }
 
 define i33 @ctlz_zero_defined() {
-; CHECK-LABEL: @ctlz_zero_defined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_zero_defined(
 ; CHECK-NEXT:    ret i33 33
 ;
   %x = call i33 @llvm.ctlz.i33(i33 0, i1 false)
   ret i33 %x
 }
 
 define i33 @ctlz_zero_undefined() {
-; CHECK-LABEL: @ctlz_zero_undefined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_zero_undefined(
 ; CHECK-NEXT:    ret i33 undef
 ;
   %x = call i33 @llvm.ctlz.i33(i33 0, i1 true)
   ret i33 %x
 }
 
 define i31 @ctpop_undef() {
-; CHECK-LABEL: @ctpop_undef(
+; CHECK-LABEL: define {{[^@]+}}@ctpop_undef(
 ; CHECK-NEXT:    ret i31 0
 ;
   %x = call i31 @llvm.ctpop.i31(i31 undef)
   ret i31 %x
 }
 
 define i32 @cttz_undef_defined() {
-; CHECK-LABEL: @cttz_undef_defined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_undef_defined(
 ; CHECK-NEXT:    ret i32 0
 ;
   %x = call i32 @llvm.cttz.i32(i32 undef, i1 false)
   ret i32 %x
 }
 
 define i32 @cttz_undef_undefined() {
-; CHECK-LABEL: @cttz_undef_undefined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_undef_undefined(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %x = call i32 @llvm.cttz.i32(i32 undef, i1 true)
   ret i32 %x
 }
 
 define i33 @ctlz_undef_defined() {
-; CHECK-LABEL: @ctlz_undef_defined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_undef_defined(
 ; CHECK-NEXT:    ret i33 0
 ;
   %x = call i33 @llvm.ctlz.i33(i33 undef, i1 false)
   ret i33 %x
 }
 
 define i33 @ctlz_undef_undefined() {
-; CHECK-LABEL: @ctlz_undef_undefined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_undef_undefined(
 ; CHECK-NEXT:    ret i33 undef
 ;
   %x = call i33 @llvm.ctlz.i33(i33 undef, i1 true)
   ret i33 %x
 }
 
 define <2 x i31> @ctpop_vector() {
-; CHECK-LABEL: @ctpop_vector(
+; CHECK-LABEL: define {{[^@]+}}@ctpop_vector(
 ; CHECK-NEXT:    ret <2 x i31> <i31 8, i31 1>
 ;
   %x = call <2 x i31> @llvm.ctpop.v2i31(<2 x i31> <i31 255, i31 16>)
   ret <2 x i31> %x
 }
 
 define <2 x i31> @ctpop_vector_undef() {
-; CHECK-LABEL: @ctpop_vector_undef(
+; CHECK-LABEL: define {{[^@]+}}@ctpop_vector_undef(
 ; CHECK-NEXT:    ret <2 x i31> zeroinitializer
 ;
   %x = call <2 x i31> @llvm.ctpop.v2i31(<2 x i31> <i31 0, i31 undef>)
   ret <2 x i31> %x
 }
 
 define <2 x i32> @cttz_vector() {
-; CHECK-LABEL: @cttz_vector(
+; CHECK-LABEL: define {{[^@]+}}@cttz_vector(
 ; CHECK-NEXT:    ret <2 x i32> <i32 0, i32 4>
 ;
   %x = call <2 x i32> @llvm.cttz.v2i32(<2 x i32> <i32 255, i32 16>, i1 true)
   ret <2 x i32> %x
 }
 
 define <2 x i32> @cttz_vector_undef_defined() {
-; CHECK-LABEL: @cttz_vector_undef_defined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_vector_undef_defined(
 ; CHECK-NEXT:    ret <2 x i32> <i32 32, i32 0>
 ;
   %x = call <2 x i32> @llvm.cttz.v2i32(<2 x i32> <i32 0, i32 undef>, i1 false)
   ret <2 x i32> %x
 }
 
 define <2 x i32> @cttz_vector_undef_undefined() {
-; CHECK-LABEL: @cttz_vector_undef_undefined(
+; CHECK-LABEL: define {{[^@]+}}@cttz_vector_undef_undefined(
 ; CHECK-NEXT:    ret <2 x i32> undef
 ;
   %x = call <2 x i32> @llvm.cttz.v2i32(<2 x i32> <i32 0, i32 undef>, i1 true)
   ret <2 x i32> %x
 }
 
 define <2 x i33> @ctlz_vector() {
-; CHECK-LABEL: @ctlz_vector(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_vector(
 ; CHECK-NEXT:    ret <2 x i33> <i33 25, i33 28>
 ;
   %x = call <2 x i33> @llvm.ctlz.v2i33(<2 x i33> <i33 255, i33 16>, i1 true)
   ret <2 x i33> %x
 }
 
 define <2 x i33> @ctlz_vector_undef_defined() {
-; CHECK-LABEL: @ctlz_vector_undef_defined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_vector_undef_defined(
 ; CHECK-NEXT:    ret <2 x i33> <i33 33, i33 0>
 ;
   %x = call <2 x i33> @llvm.ctlz.v2i33(<2 x i33> <i33 0, i33 undef>, i1 false)
   ret <2 x i33> %x
 }
 
 define <2 x i33> @ctlz_vector_undef_undefined() {
-; CHECK-LABEL: @ctlz_vector_undef_undefined(
+; CHECK-LABEL: define {{[^@]+}}@ctlz_vector_undef_undefined(
 ; CHECK-NEXT:    ret <2 x i33> undef
 ;
   %x = call <2 x i33> @llvm.ctlz.v2i33(<2 x i33> <i33 0, i33 undef>, i1 true)
   ret <2 x i33> %x
 }

llvm/test/Analysis/ConstantFolding/cast-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; Test constant fold of constant expression GEP used by ptrtoint (the
 ; "offsetof-like expression" case).
 ; This used to hit an assert due to not supporting vectors in
 ; llvm::ConstantFoldCastInstruction when handling ptrtoint.
 define <2 x i16> @test1() {
-; CHECK-LABEL: @test1(
+; CHECK-LABEL: define {{[^@]+}}@test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr ([10 x i32], [10 x i32]* null, <2 x i64> zeroinitializer, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
 ;
 entry:
   %gep = getelementptr inbounds [10 x i32], [10 x i32]* null, i16 0, <2 x i16> <i16 5, i16 7>
   %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
   ret <2 x i16> %vec
 }
 
 ; Test constant fold of constant expression GEP used by ptrtoint (the
 ; "sizeof-like expression" case).
 ; This used to hit an assert due to not supporting vectors in
 ; llvm::ConstantFoldCastInstruction when handling ptrtoint.
 define <2 x i16> @test2() {
-; CHECK-LABEL: @test2(
+; CHECK-LABEL: define {{[^@]+}}@test2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr (i32, i32* null, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
 ;
 entry:
   %gep = getelementptr i32, i32* null, <2 x i16> <i16 5, i16 7>
   %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
   ret <2 x i16> %vec
 }

llvm/test/Analysis/ConstantFolding/fneg.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 define float @fneg_constant() {
-; CHECK-LABEL: @fneg_constant(
+; CHECK-LABEL: define {{[^@]+}}@fneg_constant(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %r = fneg float -0.0
   ret float %r
 }
 
 define float @fneg_undef() {
-; CHECK-LABEL: @fneg_undef(
+; CHECK-LABEL: define {{[^@]+}}@fneg_undef(
 ; CHECK-NEXT:    ret float undef
 ;
   %r = fneg float undef
   ret float %r
 }
 
 define <4 x float> @fneg_constant_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_elts_v4f32(
+; CHECK-LABEL: define {{[^@]+}}@fneg_constant_elts_v4f32(
 ; CHECK-NEXT:    ret <4 x float> <float 0.000000e+00, float -0.000000e+00, float 1.000000e+00, float -1.000000e+00>
 ;
   %r = fneg <4 x float> <float -0.0, float 0.0, float -1.0, float 1.0>
   ret <4 x float> %r
 }
 
 define <4 x float> @fneg_constant_undef_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_undef_elts_v4f32(
+; CHECK-LABEL: define {{[^@]+}}@fneg_constant_undef_elts_v4f32(
 ; CHECK-NEXT:    ret <4 x float> <float 0.000000e+00, float undef, float undef, float -1.000000e+00>
 ;
   %r = fneg <4 x float> <float -0.0, float undef, float undef, float 1.0>
   ret <4 x float> %r
 }
 
 define <4 x float> @fneg_constant_all_undef_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_all_undef_elts_v4f32(
+; CHECK-LABEL: define {{[^@]+}}@fneg_constant_all_undef_elts_v4f32(
 ; CHECK-NEXT:    ret <4 x float> undef
 ;
   %r = fneg <4 x float> <float undef, float undef, float undef, float undef>
   ret <4 x float> %r
 }

llvm/test/Analysis/ConstantFolding/funnel-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S -o - | FileCheck %s
 
 declare i32 @llvm.fshl.i32(i32, i32, i32)
 declare i32 @llvm.fshr.i32(i32, i32, i32)
 declare i7 @llvm.fshl.i7(i7, i7, i7)
 declare i7 @llvm.fshr.i7(i7, i7, i7)
 declare <4 x i8> @llvm.fshl.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
 declare <4 x i8> @llvm.fshr.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
 
 ; extract(concat(0x12345678, 0xABCDEF01) << 5) = 0x468ACF15
 
 define i32 @fshl_i32() {
-; CHECK-LABEL: @fshl_i32(
+; CHECK-LABEL: define {{[^@]+}}@fshl_i32(
 ; CHECK-NEXT:    ret i32 1183502101
 ;
   %f = call i32 @llvm.fshl.i32(i32 305419896, i32 2882400001, i32 5)
   ret i32 %f
 }
 
 ; extract(concat(0x12345678, 0xABCDEF01) >> 5) = 0xC55E6F78
 ; Try an oversized shift to test modulo functionality.
 
 define i32 @fshr_i32() {
-; CHECK-LABEL: @fshr_i32(
+; CHECK-LABEL: define {{[^@]+}}@fshr_i32(
 ; CHECK-NEXT:    ret i32 -983666824
 ;
   %f = call i32 @llvm.fshr.i32(i32 305419896, i32 2882400001, i32 37)
   ret i32 %f
 }
 
 ; Use a weird type.
 ; Try an oversized shift to test modulo functionality.
 
 ; extract(concat(0b1110000, 0b1111111) << 2) = 0b1000011
 
 define i7 @fshl_i7() {
-; CHECK-LABEL: @fshl_i7(
+; CHECK-LABEL: define {{[^@]+}}@fshl_i7(
 ; CHECK-NEXT:    ret i7 -61
 ;
   %f = call i7 @llvm.fshl.i7(i7 112, i7 127, i7 9)
   ret i7 %f
 }
 
 ; extract(concat(0b1110000, 0b1111111) >> 2) = 0b0011111
 ; Try an oversized shift to test modulo functionality.
 
 define i7 @fshr_i7() {
-; CHECK-LABEL: @fshr_i7(
+; CHECK-LABEL: define {{[^@]+}}@fshr_i7(
 ; CHECK-NEXT:    ret i7 31
 ;
   %f = call i7 @llvm.fshr.i7(i7 112, i7 127, i7 16)
   ret i7 %f
 }
 
 ; Vectors are folded by handling each scalar element individually, so this is the equivalent of 4 scalar tests:
 ; extract(concat(0x00, 0xFF) << 0) = 0x00
 ; extract(concat(0xFF, 0x00) << 0) = 0xFF
 ; extract(concat(0x10, 0x55) << 1) = 0x20
 ; extract(concat(0x11, 0xAA) << 2) = 0x46
 
 define <4 x i8> @fshl_v4i8() {
-; CHECK-LABEL: @fshl_v4i8(
+; CHECK-LABEL: define {{[^@]+}}@fshl_v4i8(
 ; CHECK-NEXT:    ret <4 x i8> <i8 0, i8 -1, i8 32, i8 70>
 ;
   %f = call <4 x i8> @llvm.fshl.v4i8(<4 x i8> <i8 0, i8 -1, i8 16, i8 17>, <4 x i8> <i8 -1, i8 0, i8 85, i8 170>, <4 x i8> <i8 0, i8 8, i8 9, i8 10>)
   ret <4 x i8> %f
 }
 
 ; Vectors are folded by handling each scalar element individually, so this is the equivalent of 4 scalar tests:
 ; extract(concat(0x00, 0xFF) >> 0) = 0xFF
 ; extract(concat(0xFF, 0x00) >> 0) = 0x00
 ; extract(concat(0x10, 0x55) >> 1) = 0x2A
 ; extract(concat(0x11, 0xAA) >> 2) = 0x6A
 
 define <4 x i8> @fshr_v4i8() {
-; CHECK-LABEL: @fshr_v4i8(
+; CHECK-LABEL: define {{[^@]+}}@fshr_v4i8(
 ; CHECK-NEXT:    ret <4 x i8> <i8 -1, i8 0, i8 42, i8 106>
 ;
   %f = call <4 x i8> @llvm.fshr.v4i8(<4 x i8> <i8 0, i8 -1, i8 16, i8 17>, <4 x i8> <i8 -1, i8 0, i8 85, i8 170>, <4 x i8> <i8 0, i8 8, i8 9, i8 10>)
   ret <4 x i8> %f
 }
 
 ; Undef handling
 
 define i32 @fshl_scalar_all_undef() {
-; CHECK-LABEL: @fshl_scalar_all_undef(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_all_undef(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshl.i32(i32 undef, i32 undef, i32 undef)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_all_undef() {
-; CHECK-LABEL: @fshr_scalar_all_undef(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_all_undef(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshr.i32(i32 undef, i32 undef, i32 undef)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_shamt() {
-; CHECK-LABEL: @fshl_scalar_undef_shamt(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_shamt(
 ; CHECK-NEXT:    ret i32 1
 ;
   %f = call i32 @llvm.fshl.i32(i32 1, i32 2, i32 undef)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_shamt() {
-; CHECK-LABEL: @fshr_scalar_undef_shamt(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_shamt(
 ; CHECK-NEXT:    ret i32 2
 ;
   %f = call i32 @llvm.fshr.i32(i32 1, i32 2, i32 undef)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_ops() {
-; CHECK-LABEL: @fshl_scalar_undef_ops(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_ops(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshl.i32(i32 undef, i32 undef, i32 7)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_ops() {
-; CHECK-LABEL: @fshr_scalar_undef_ops(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_ops(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshr.i32(i32 undef, i32 undef, i32 7)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_op1_zero_shift() {
-; CHECK-LABEL: @fshl_scalar_undef_op1_zero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_op1_zero_shift(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshl.i32(i32 undef, i32 1, i32 0)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_op2_zero_shift() {
-; CHECK-LABEL: @fshl_scalar_undef_op2_zero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_op2_zero_shift(
 ; CHECK-NEXT:    ret i32 1
 ;
   %f = call i32 @llvm.fshl.i32(i32 1, i32 undef, i32 32)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_op1_zero_shift() {
-; CHECK-LABEL: @fshr_scalar_undef_op1_zero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_op1_zero_shift(
 ; CHECK-NEXT:    ret i32 1
 ;
   %f = call i32 @llvm.fshr.i32(i32 undef, i32 1, i32 64)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_op2_zero_shift() {
-; CHECK-LABEL: @fshr_scalar_undef_op2_zero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_op2_zero_shift(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %f = call i32 @llvm.fshr.i32(i32 1, i32 undef, i32 0)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_op1_nonzero_shift() {
-; CHECK-LABEL: @fshl_scalar_undef_op1_nonzero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_op1_nonzero_shift(
 ; CHECK-NEXT:    ret i32 255
 ;
   %f = call i32 @llvm.fshl.i32(i32 undef, i32 -1, i32 8)
   ret i32 %f
 }
 
 define i32 @fshl_scalar_undef_op2_nonzero_shift() {
-; CHECK-LABEL: @fshl_scalar_undef_op2_nonzero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshl_scalar_undef_op2_nonzero_shift(
 ; CHECK-NEXT:    ret i32 -256
 ;
   %f = call i32 @llvm.fshl.i32(i32 -1, i32 undef, i32 8)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_op1_nonzero_shift() {
-; CHECK-LABEL: @fshr_scalar_undef_op1_nonzero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_op1_nonzero_shift(
 ; CHECK-NEXT:    ret i32 16777215
 ;
   %f = call i32 @llvm.fshr.i32(i32 undef, i32 -1, i32 8)
   ret i32 %f
 }
 
 define i32 @fshr_scalar_undef_op2_nonzero_shift() {
-; CHECK-LABEL: @fshr_scalar_undef_op2_nonzero_shift(
+; CHECK-LABEL: define {{[^@]+}}@fshr_scalar_undef_op2_nonzero_shift(
 ; CHECK-NEXT:    ret i32 -16777216
 ;
   %f = call i32 @llvm.fshr.i32(i32 -1, i32 undef, i32 8)
   ret i32 %f
 }
 
 ; Undef/Undef/Undef; 1/2/Undef; Undef/Undef/3; Undef/1/0
 define <4 x i8> @fshl_vector_mix1() {
-; CHECK-LABEL: @fshl_vector_mix1(
+; CHECK-LABEL: define {{[^@]+}}@fshl_vector_mix1(
 ; CHECK-NEXT:    ret <4 x i8> <i8 undef, i8 1, i8 undef, i8 undef>
 ;
   %f = call <4 x i8> @llvm.fshl.v4i8(<4 x i8> <i8 undef, i8 1, i8 undef, i8 undef>, <4 x i8> <i8 undef, i8 2, i8 undef, i8 1>, <4 x i8> <i8 undef, i8 undef, i8 3, i8 0>)
   ret <4 x i8> %f
 }
 
 ; 1/Undef/8; Undef/-1/2; -1/Undef/2; 7/8/4
 define <4 x i8> @fshl_vector_mix2() {
-; CHECK-LABEL: @fshl_vector_mix2(
+; CHECK-LABEL: define {{[^@]+}}@fshl_vector_mix2(
 ; CHECK-NEXT:    ret <4 x i8> <i8 1, i8 3, i8 -4, i8 112>
 ;
   %f = call <4 x i8> @llvm.fshl.v4i8(<4 x i8> <i8 1, i8 undef, i8 -1, i8 7>, <4 x i8> <i8 undef, i8 -1, i8 undef, i8 8>, <4 x i8> <i8 8, i8 2, i8 2, i8 4>)
   ret <4 x i8> %f
 }
 
 ; Undef/Undef/Undef; 1/2/Undef; Undef/Undef/3; Undef/1/0
 define <4 x i8> @fshr_vector_mix1() {
-; CHECK-LABEL: @fshr_vector_mix1(
+; CHECK-LABEL: define {{[^@]+}}@fshr_vector_mix1(
 ; CHECK-NEXT:    ret <4 x i8> <i8 undef, i8 2, i8 undef, i8 1>
 ;
   %f = call <4 x i8> @llvm.fshr.v4i8(<4 x i8> <i8 undef, i8 1, i8 undef, i8 undef>, <4 x i8> <i8 undef, i8 2, i8 undef, i8 1>, <4 x i8> <i8 undef, i8 undef, i8 3, i8 0>)
   ret <4 x i8> %f
 }
 
 ; 1/Undef/8; Undef/-1/2; -1/Undef/2; 7/8/4
 define <4 x i8> @fshr_vector_mix2() {
-; CHECK-LABEL: @fshr_vector_mix2(
+; CHECK-LABEL: define {{[^@]+}}@fshr_vector_mix2(
 ; CHECK-NEXT:    ret <4 x i8> <i8 undef, i8 63, i8 -64, i8 112>
 ;
   %f = call <4 x i8> @llvm.fshr.v4i8(<4 x i8> <i8 1, i8 undef, i8 -1, i8 7>, <4 x i8> <i8 undef, i8 -1, i8 undef, i8 8>, <4 x i8> <i8 8, i8 2, i8 2, i8 4>)
   ret <4 x i8> %f
 }

llvm/test/Analysis/ConstantFolding/gep-zeroinit-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S -o - | FileCheck %s
 
 ; Testcase that verify that we don't get a faulty bitcast that cast between
 ; different sizes.
 
 %rec8 = type { i16 }
 @a = global [1 x %rec8] zeroinitializer
 
 define <2 x i16*> @test_gep() {
-; CHECK-LABEL: @test_gep(
+; CHECK-LABEL: define {{[^@]+}}@test_gep(
 ; CHECK-NEXT:    ret <2 x i16*> <i16* getelementptr inbounds ([1 x %rec8], [1 x %rec8]* @a, i32 0, i32 0, i32 0), i16* getelementptr inbounds ([1 x %rec8], [1 x %rec8]* @a, i32 0, i32 0, i32 0)>
 ;
   %A = getelementptr [1 x %rec8], [1 x %rec8]* @a, <2 x i16> zeroinitializer, <2 x i64> zeroinitializer
   %B = bitcast <2 x %rec8*> %A to <2 x i16*>
   ret <2 x i16*> %B
 }
 
 ; Testcase that verify the cast-of-cast when the outer/second cast is to a
 ; vector type.
 
 define <4 x i16> @test_mmx_const() {
-; CHECK-LABEL: @test_mmx_const(
+; CHECK-LABEL: define {{[^@]+}}@test_mmx_const(
 ; CHECK-NEXT:    ret <4 x i16> zeroinitializer
 ;
   %A = bitcast <2 x i32> zeroinitializer to x86_mmx
   %B = bitcast x86_mmx %A to <4 x i16>
   ret <4 x i16> %B
 }

llvm/test/Analysis/ConstantFolding/math-1.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -early-cse -S -o - %s | FileCheck %s
 
 declare double @acos(double)
 define double @f_acos() {
-; CHECK-LABEL: @f_acos(
+; CHECK-LABEL: define {{[^@]+}}@f_acos(
 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %res = tail call fast double @acos(double 1.0)
   ret double %res
 }
 
 declare float @asinf(float)
 define float @f_asinf() {
-; CHECK-LABEL: @f_asinf(
-; CHECK-NEXT:    ret float 0x3FF921FB{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_asinf(
+; CHECK-NEXT:    ret float 0x3FF921FB60000000
 ;
   %res = tail call fast float @asinf(float 1.0)
   ret float %res
 }
 
 declare double @atan(double)
 define double @f_atan() {
-; CHECK-LABEL: @f_atan(
+; CHECK-LABEL: define {{[^@]+}}@f_atan(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan(double 1.000000e+00)
-; CHECK-NEXT:    ret double 0x3FE921FB
+; CHECK-NEXT:    ret double 0x3FE921FB54442D18
 ;
   %res = tail call fast double @atan(double 1.0)
   ret double %res
 }
 
 declare float @cosf(float)
 define float @f_cosf() {
-; CHECK-LABEL: @f_cosf(
-; CHECK-NEXT:    ret float 0x3FE14A2{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_cosf(
+; CHECK-NEXT:    ret float 0x3FE14A2800000000
 ;
   %res = tail call fast float @cosf(float 1.0)
   ret float %res
 }
 
 declare float @llvm.cos.f32(float)
 define float @i_cosf() {
-; CHECK-LABEL: @i_cosf(
-; CHECK-NEXT:    ret float 0x3FE14A2
+; CHECK-LABEL: define {{[^@]+}}@i_cosf(
+; CHECK-NEXT:    ret float 0x3FE14A2800000000
 ;
   %res = tail call fast float @llvm.cos.f32(float 1.0)
   ret float %res
 }
 
 declare double @cosh(double)
 define double @f_cosh() {
-; CHECK-LABEL: @f_cosh(
-; CHECK-NEXT:    ret double 0x3FF8B075{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_cosh(
+; CHECK-NEXT:    ret double 0x3FF8B07551D9F550
 ;
   %res = tail call fast double @cosh(double 1.0)
   ret double %res
 }
 
 declare float @expf(float)
 define float @f_expf() {
-; CHECK-LABEL: @f_expf(
-; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_expf(
+; CHECK-NEXT:    ret float 0x4005BF0A80000000
 ;
   %res = tail call fast float @expf(float 1.0)
   ret float %res
 }
 
 declare float @llvm.exp.f32(float)
 define float @i_expf() {
-; CHECK-LABEL: @i_expf(
-; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@i_expf(
+; CHECK-NEXT:    ret float 0x4005BF0A80000000
 ;
   %res = tail call fast float @llvm.exp.f32(float 1.0)
   ret float %res
 }
 
 declare double @exp2(double)
 define double @f_exp2() {
-; CHECK-LABEL: @f_exp2(
+; CHECK-LABEL: define {{[^@]+}}@f_exp2(
 ; CHECK-NEXT:    ret double 2.000000e+00
 ;
   %res = tail call fast double @exp2(double 1.0)
   ret double %res
 }
 
 declare double @llvm.exp2.f64(double)
 define double @i_exp2() {
-; CHECK-LABEL: @i_exp2(
+; CHECK-LABEL: define {{[^@]+}}@i_exp2(
 ; CHECK-NEXT:    ret double 2.000000e+00
 ;
   %res = tail call fast double @llvm.exp2.f64(double 1.0)
   ret double %res
 }
 
 ; FIXME: exp10() is not widely supported.
 declare float @exp10f(float)
 define float @f_exp10f() {
-; CHECK-LABEL: @f_exp10f(
+; CHECK-LABEL: define {{[^@]+}}@f_exp10f(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call float @exp10f(float 1.000000e+00)
 ; CHECK-NEXT:    ret float [[RES]]
 ;
   %res = tail call float @exp10f(float 1.0)
   ret float %res
 }
 
 declare double @log(double)
 define double @f_log() {
-; CHECK-LABEL: @f_log(
+; CHECK-LABEL: define {{[^@]+}}@f_log(
 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %res = tail call fast double @log(double 1.0)
   ret double %res
 }
 
 declare double @llvm.log.f64(double)
 define double @i_log() {
-; CHECK-LABEL: @i_log(
+; CHECK-LABEL: define {{[^@]+}}@i_log(
 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %res = tail call fast double @llvm.log.f64(double 1.0)
   ret double %res
 }
 
 declare float @log2f(float)
 define float @f_log2f() {
-; CHECK-LABEL: @f_log2f(
+; CHECK-LABEL: define {{[^@]+}}@f_log2f(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %res = tail call fast float @log2f(float 1.0)
   ret float %res
 }
 
 declare float @llvm.log2.f32(float)
 define float @i_log2f() {
-; CHECK-LABEL: @i_log2f(
+; CHECK-LABEL: define {{[^@]+}}@i_log2f(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %res = tail call fast float @llvm.log2.f32(float 1.0)
   ret float %res
 }
 
 declare double @log10(double)
 define double @f_log10() {
-; CHECK-LABEL: @f_log10(
+; CHECK-LABEL: define {{[^@]+}}@f_log10(
 ; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %res = tail call fast double @log10(double 1.0)
   ret double %res
 }
 
 declare float @sinf(float)
 define float @f_sinf() {
-; CHECK-LABEL: @f_sinf(
-; CHECK-NEXT:    ret float 0x3FEAED54{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_sinf(
+; CHECK-NEXT:    ret float 0x3FEAED5480000000
 ;
   %res = tail call fast float @sinf(float 1.0)
   ret float %res
 }
 
 declare double @sinh(double)
 define double @f_sinh() {
-; CHECK-LABEL: @f_sinh(
-; CHECK-NEXT:    ret double 0x3FF2CD9F{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_sinh(
+; CHECK-NEXT:    ret double 0x3FF2CD9FC44EB982
 ;
   %res = tail call fast double @sinh(double 1.0)
   ret double %res
 }
 
 declare float @sqrtf(float)
 define float @f_sqrtf() {
-; CHECK-LABEL: @f_sqrtf(
+; CHECK-LABEL: define {{[^@]+}}@f_sqrtf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @sqrtf(float 1.0)
   ret float %res
 }
 
 declare double @tan(double)
 define double @f_tan() {
-; CHECK-LABEL: @f_tan(
-; CHECK-NEXT:    ret double 0x3FF8EB24{{.+}}
+; CHECK-LABEL: define {{[^@]+}}@f_tan(
+; CHECK-NEXT:    ret double 0x3FF8EB245CBEE3A6
 ;
   %res = tail call fast double @tan(double 1.0)
   ret double %res
 }
 
 declare float @tanhf(float)
 define float @f_tanhf() {
-; CHECK-LABEL: @f_tanhf(
+; CHECK-LABEL: define {{[^@]+}}@f_tanhf(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast float @tanhf(float 1.000000e+00)
-; CHECK-NEXT:    ret float 0x3FE85EFA{{.+}}
+; CHECK-NEXT:    ret float 0x3FE85EFAC0000000
 ;
   %res = tail call fast float @tanhf(float 1.0)
   ret float %res
 }

llvm/test/Analysis/ConstantFolding/math-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -early-cse -S -o - %s | FileCheck %s
 
 declare double @atan2(double, double)
 define double @f_atan2() {
-; CHECK-LABEL: @f_atan2(
+; CHECK-LABEL: define {{[^@]+}}@f_atan2(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan2(double 1.000000e+00, double 2.000000e+00)
-; CHECK-NEXT:    ret double 0x3FDDAC6{{.+}}
+; CHECK-NEXT:    ret double 0x3FDDAC670561BB4F
 ;
   %res = tail call fast double @atan2(double 1.0, double 2.0)
   ret double %res
 }
 
 declare float @fmodf(float, float)
 define float @f_fmodf() {
-; CHECK-LABEL: @f_fmodf(
+; CHECK-LABEL: define {{[^@]+}}@f_fmodf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @fmodf(float 1.0, float 2.0)
   ret float %res
 }
 
 declare double @pow(double, double)
 define double @f_pow() {
-; CHECK-LABEL: @f_pow(
+; CHECK-LABEL: define {{[^@]+}}@f_pow(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @pow(double 1.0, double 2.0)
   ret double %res
 }
 
 declare float @llvm.pow.f32(float, float)
 define float @i_powf() {
-; CHECK-LABEL: @i_powf(
+; CHECK-LABEL: define {{[^@]+}}@i_powf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @llvm.pow.f32(float 1.0, float 2.0)
   ret float %res
 }
 
 declare double @llvm.powi.f64(double, i32)
 define double @i_powi() {
-; CHECK-LABEL: @i_powi(
+; CHECK-LABEL: define {{[^@]+}}@i_powi(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @llvm.powi.f64(double 1.0, i32 2)
   ret double %res
 }

llvm/test/Analysis/ConstantFolding/rint.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -early-cse < %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
 declare double @llvm.rint.f64(double) #0
 
 define float @constant_fold_rint_f32_01() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_01(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_01(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %x = call float @nearbyintf(float 1.25) #0
   ret float %x
 }
 
 define float @constant_fold_rint_f32_02() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_02(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_02(
 ; CHECK-NEXT:    ret float -1.000000e+00
 ;
   %x = call float @llvm.nearbyint.f32(float -1.25) #0
   ret float %x
 }
 
 define float @constant_fold_rint_f32_03() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_03(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_03(
 ; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %x = call float @rintf(float 1.5) #0
   ret float %x
 }
 
 define float @constant_fold_rint_f32_04() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_04(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_04(
 ; CHECK-NEXT:    ret float -2.000000e+00
 ;
   %x = call float @llvm.rint.f32(float -1.5) #0
   ret float %x
 }
 
 define float @constant_fold_rint_f32_05() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_05(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_05(
 ; CHECK-NEXT:    ret float 3.000000e+00
 ;
   %x = call float @nearbyintf(float 2.75) #0
   ret float %x
 }
 
 define float @constant_fold_rint_f32_06() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_06(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f32_06(
 ; CHECK-NEXT:    ret float -3.000000e+00
 ;
   %x = call float @llvm.nearbyint.f32(float -2.75) #0
   ret float %x
 }
 
 define double @constant_fold_rint_f64_01() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_01(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_01(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %x = call double @rint(double 1.3) #0
   ret double %x
 }
 
 define double @constant_fold_rint_f64_02() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_02(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_02(
 ; CHECK-NEXT:    ret double -1.000000e+00
 ;
   %x = call double @llvm.rint.f64(double -1.3) #0
   ret double %x
 }
 
 define double @constant_fold_rint_f64_03() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_03(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_03(
 ; CHECK-NEXT:    ret double 2.000000e+00
 ;
   %x = call double @nearbyint(double 1.5) #0
   ret double %x
 }
 
 define double @constant_fold_rint_f64_04() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_04(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_04(
 ; CHECK-NEXT:    ret double -2.000000e+00
 ;
   %x = call double @llvm.nearbyint.f64(double -1.5) #0
   ret double %x
 }
 
 define double @constant_fold_rint_f64_05() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_05(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_05(
 ; CHECK-NEXT:    ret double 3.000000e+00
 ;
   %x = call double @rint(double 2.7) #0
   ret double %x
 }
 
 define double @constant_fold_rint_f64_06() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_06(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_rint_f64_06(
 ; CHECK-NEXT:    ret double -3.000000e+00
 ;
   %x = call double @llvm.rint.f64(double -2.7) #0
   ret double %x
 }
 
 attributes #0 = { nounwind readnone }

llvm/test/Analysis/ConstantFolding/saturating-add-sub.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 declare i8 @llvm.uadd.sat.i8(i8, i8)
 declare i8 @llvm.sadd.sat.i8(i8, i8)
 declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8>, <2 x i8>)
 
 declare i8 @llvm.usub.sat.i8(i8, i8)
 declare i8 @llvm.ssub.sat.i8(i8, i8)
 declare <2 x i8> @llvm.usub.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8>, <2 x i8>)
 
 define i8 @test_uadd_scalar_no_sat() {
-; CHECK-LABEL: @test_uadd_scalar_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_scalar_no_sat(
 ; CHECK-NEXT:    ret i8 30
 ;
   %x = call i8 @llvm.uadd.sat.i8(i8 10, i8 20)
   ret i8 %x
 }
 
 define i8 @test_uadd_scalar_sat() {
-; CHECK-LABEL: @test_uadd_scalar_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_scalar_sat(
 ; CHECK-NEXT:    ret i8 -1
 ;
   %x = call i8 @llvm.uadd.sat.i8(i8 250, i8 100)
   ret i8 %x
 }
 
 define i8 @test_sadd_scalar_no_sat() {
-; CHECK-LABEL: @test_sadd_scalar_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_scalar_no_sat(
 ; CHECK-NEXT:    ret i8 -10
 ;
   %x = call i8 @llvm.sadd.sat.i8(i8 10, i8 -20)
   ret i8 %x
 }
 
 define i8 @test_sadd_scalar_sat_pos() {
-; CHECK-LABEL: @test_sadd_scalar_sat_pos(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_scalar_sat_pos(
 ; CHECK-NEXT:    ret i8 127
 ;
   %x = call i8 @llvm.sadd.sat.i8(i8 120, i8 10)
   ret i8 %x
 }
 
 define i8 @test_sadd_scalar_sat_neg() {
-; CHECK-LABEL: @test_sadd_scalar_sat_neg(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_scalar_sat_neg(
 ; CHECK-NEXT:    ret i8 -128
 ;
   %x = call i8 @llvm.sadd.sat.i8(i8 -120, i8 -10)
   ret i8 %x
 }
 
 define <2 x i8> @test_uadd_vector_no_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_uadd_vector_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_no_sat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 20, i8 30>
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 10, i8 15>, <2 x i8> <i8 10, i8 15>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_uadd_vector_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_uadd_vector_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_sat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 100, i8 200>, <2 x i8> <i8 250, i8 100>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_no_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_sadd_vector_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_no_sat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -10, i8 -30>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 10, i8 -15>, <2 x i8> <i8 -20, i8 -15>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_sat_pos(<2 x i8> %a) {
-; CHECK-LABEL: @test_sadd_vector_sat_pos(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_sat_pos(
 ; CHECK-NEXT:    ret <2 x i8> <i8 127, i8 127>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 100, i8 10>, <2 x i8> <i8 30, i8 120>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_sat_neg(<2 x i8> %a) {
-; CHECK-LABEL: @test_sadd_vector_sat_neg(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_sat_neg(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -128, i8 -128>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 -100, i8 -10>, <2 x i8> <i8 -30, i8 -120>)
   ret <2 x i8> %x
 }
 
 define i8 @test_usub_scalar_no_sat() {
-; CHECK-LABEL: @test_usub_scalar_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_scalar_no_sat(
 ; CHECK-NEXT:    ret i8 10
 ;
   %x = call i8 @llvm.usub.sat.i8(i8 20, i8 10)
   ret i8 %x
 }
 
 define i8 @test_usub_scalar_sat() {
-; CHECK-LABEL: @test_usub_scalar_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_scalar_sat(
 ; CHECK-NEXT:    ret i8 0
 ;
   %x = call i8 @llvm.usub.sat.i8(i8 200, i8 250)
   ret i8 %x
 }
 
 define i8 @test_ssub_scalar_no_sat() {
-; CHECK-LABEL: @test_ssub_scalar_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_scalar_no_sat(
 ; CHECK-NEXT:    ret i8 -30
 ;
   %x = call i8 @llvm.ssub.sat.i8(i8 -10, i8 20)
   ret i8 %x
 }
 
 define i8 @test_ssub_scalar_sat_pos() {
-; CHECK-LABEL: @test_ssub_scalar_sat_pos(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_scalar_sat_pos(
 ; CHECK-NEXT:    ret i8 127
 ;
   %x = call i8 @llvm.ssub.sat.i8(i8 120, i8 -10)
   ret i8 %x
 }
 
 define i8 @test_ssub_scalar_sat_neg() {
-; CHECK-LABEL: @test_ssub_scalar_sat_neg(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_scalar_sat_neg(
 ; CHECK-NEXT:    ret i8 -128
 ;
   %x = call i8 @llvm.ssub.sat.i8(i8 -120, i8 10)
   ret i8 %x
 }
 
 define <2 x i8> @test_usub_vector_no_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_usub_vector_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_no_sat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 10, i8 5>
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 20, i8 15>, <2 x i8> <i8 10, i8 10>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_usub_vector_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_usub_vector_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_sat(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 100, i8 200>, <2 x i8> <i8 150, i8 250>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_no_sat(<2 x i8> %a) {
-; CHECK-LABEL: @test_ssub_vector_no_sat(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_no_sat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 30, i8 0>
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 10, i8 -15>, <2 x i8> <i8 -20, i8 -15>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_sat_pos(<2 x i8> %a) {
-; CHECK-LABEL: @test_ssub_vector_sat_pos(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_sat_pos(
 ; CHECK-NEXT:    ret <2 x i8> <i8 127, i8 127>
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 100, i8 10>, <2 x i8> <i8 -30, i8 -120>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_sat_neg(<2 x i8> %a) {
-; CHECK-LABEL: @test_ssub_vector_sat_neg(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_sat_neg(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -128, i8 -128>
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 -100, i8 -10>, <2 x i8> <i8 30, i8 120>)
   ret <2 x i8> %x
 }
 
 ; Tests for undef handling
 
 define i8 @test_uadd_scalar_both_undef() {
-; CHECK-LABEL: @test_uadd_scalar_both_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_scalar_both_undef(
 ; CHECK-NEXT:    ret i8 undef
 ;
   %x = call i8 @llvm.uadd.sat.i8(i8 undef, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_sadd_scalar_both_undef() {
-; CHECK-LABEL: @test_sadd_scalar_both_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_scalar_both_undef(
 ; CHECK-NEXT:    ret i8 undef
 ;
   %x = call i8 @llvm.sadd.sat.i8(i8 undef, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_usub_scalar_both_undef() {
-; CHECK-LABEL: @test_usub_scalar_both_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_scalar_both_undef(
 ; CHECK-NEXT:    ret i8 undef
 ;
   %x = call i8 @llvm.usub.sat.i8(i8 undef, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_ssub_scalar_both_undef() {
-; CHECK-LABEL: @test_ssub_scalar_both_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_scalar_both_undef(
 ; CHECK-NEXT:    ret i8 undef
 ;
   %x = call i8 @llvm.ssub.sat.i8(i8 undef, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_uadd_scalar_op2_undef() {
-; CHECK-LABEL: @test_uadd_scalar_op2_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_scalar_op2_undef(
 ; CHECK-NEXT:    ret i8 -1
 ;
   %x = call i8 @llvm.uadd.sat.i8(i8 10, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_sadd_scalar_op1_undef() {
-; CHECK-LABEL: @test_sadd_scalar_op1_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_scalar_op1_undef(
 ; CHECK-NEXT:    ret i8 -1
 ;
   %x = call i8 @llvm.sadd.sat.i8(i8 undef, i8 10)
   ret i8 %x
 }
 
 define i8 @test_usub_scalar_op2_undef() {
-; CHECK-LABEL: @test_usub_scalar_op2_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_scalar_op2_undef(
 ; CHECK-NEXT:    ret i8 0
 ;
   %x = call i8 @llvm.usub.sat.i8(i8 10, i8 undef)
   ret i8 %x
 }
 
 define i8 @test_usub_scalar_op1_undef() {
-; CHECK-LABEL: @test_usub_scalar_op1_undef(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_scalar_op1_undef(
 ; CHECK-NEXT:    ret i8 0
 ;
   %x = call i8 @llvm.usub.sat.i8(i8 undef, i8 10)
   ret i8 %x
 }
 
 define <2 x i8> @test_uadd_vector_both_undef_splat() {
-; CHECK-LABEL: @test_uadd_vector_both_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_both_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> undef, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_both_undef_splat() {
-; CHECK-LABEL: @test_sadd_vector_both_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_both_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_usub_vector_both_undef_splat() {
-; CHECK-LABEL: @test_usub_vector_both_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_both_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> undef, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_both_undef_splat() {
-; CHECK-LABEL: @test_ssub_vector_both_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_both_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> undef, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_uadd_vector_op2_undef_splat() {
-; CHECK-LABEL: @test_uadd_vector_op2_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_op2_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 10, i8 20>, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_op1_undef_splat() {
-; CHECK-LABEL: @test_sadd_vector_op1_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_op1_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> undef, <2 x i8> <i8 10, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_usub_vector_op2_undef_splat() {
-; CHECK-LABEL: @test_usub_vector_op2_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_op2_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 10, i8 20>, <2 x i8> undef)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_op1_undef_splat() {
-; CHECK-LABEL: @test_ssub_vector_op1_undef_splat(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_op1_undef_splat(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> undef, <2 x i8> <i8 10, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_uadd_vector_op2_undef_mix1() {
-; CHECK-LABEL: @test_uadd_vector_op2_undef_mix1(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_op2_undef_mix1(
 ; CHECK-NEXT:    ret <2 x i8> <i8 30, i8 undef>
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 10, i8 undef>, <2 x i8> <i8 20, i8 undef>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_uadd_vector_op2_undef_mix2() {
-; CHECK-LABEL: @test_uadd_vector_op2_undef_mix2(
+; CHECK-LABEL: define {{[^@]+}}@test_uadd_vector_op2_undef_mix2(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> <i8 10, i8 undef>, <2 x i8> <i8 undef, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_op1_undef_mix1() {
-; CHECK-LABEL: @test_sadd_vector_op1_undef_mix1(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_op1_undef_mix1(
 ; CHECK-NEXT:    ret <2 x i8> <i8 undef, i8 30>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 undef, i8 10>, <2 x i8> <i8 undef, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_sadd_vector_op1_undef_mix2() {
-; CHECK-LABEL: @test_sadd_vector_op1_undef_mix2(
+; CHECK-LABEL: define {{[^@]+}}@test_sadd_vector_op1_undef_mix2(
 ; CHECK-NEXT:    ret <2 x i8> <i8 -1, i8 -1>
 ;
   %x = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> <i8 undef, i8 10>, <2 x i8> <i8 20, i8 undef>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_usub_vector_op2_undef_mix1() {
-; CHECK-LABEL: @test_usub_vector_op2_undef_mix1(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_op2_undef_mix1(
 ; CHECK-NEXT:    ret <2 x i8> <i8 0, i8 undef>
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 10, i8 undef>, <2 x i8> <i8 20, i8 undef>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_usub_vector_op2_undef_mix2() {
-; CHECK-LABEL: @test_usub_vector_op2_undef_mix2(
+; CHECK-LABEL: define {{[^@]+}}@test_usub_vector_op2_undef_mix2(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> <i8 10, i8 undef>, <2 x i8> <i8 undef, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_op1_undef_mix1() {
-; CHECK-LABEL: @test_ssub_vector_op1_undef_mix1(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_op1_undef_mix1(
 ; CHECK-NEXT:    ret <2 x i8> <i8 undef, i8 -10>
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 undef, i8 10>, <2 x i8> <i8 undef, i8 20>)
   ret <2 x i8> %x
 }
 
 define <2 x i8> @test_ssub_vector_op1_undef_mix2() {
-; CHECK-LABEL: @test_ssub_vector_op1_undef_mix2(
+; CHECK-LABEL: define {{[^@]+}}@test_ssub_vector_op1_undef_mix2(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %x = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> <i8 undef, i8 10>, <2 x i8> <i8 20, i8 undef>)
   ret <2 x i8> %x
 }

llvm/test/Analysis/ConstantFolding/smul-fix-sat.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 ;-----------------------------------------------------------------------------
 ; Simple test using scalar layout.
 ;-----------------------------------------------------------------------------
 
 declare i32 @llvm.smul.fix.sat.i32(i32, i32, i32)
 
 define i32 @test_smul_fix_sat_i32_0() {
-; CHECK-LABEL: @test_smul_fix_sat_i32_0(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_i32_0(
 ; CHECK-NEXT:    ret i32 536870912
 ;
   %r = call i32 @llvm.smul.fix.sat.i32(i32 1073741824, i32 1073741824, i32 31) ; 0.5 * 0.5
   ret i32 %r
 }
 
 ;-----------------------------------------------------------------------------
 ; More extensive tests based on vectors (basically using the scalar fold
 ; for each index).
 ;-----------------------------------------------------------------------------
 
 declare <8 x i3> @llvm.smul.fix.sat.v8i3(<8 x i3>, <8 x i3>, i32)
 
 define <8 x i3> @test_smul_fix_sat_v8i3_0() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_0(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_0(
 ; CHECK-NEXT:    ret <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 0, i3 -4, i3 -4, i3 -4>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_1() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_1(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_1(
 ; CHECK-NEXT:    ret <8 x i3> <i3 3, i3 3, i3 3, i3 2, i3 0, i3 -2, i3 -4, i3 -4>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_2() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_2(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_2(
 ; CHECK-NEXT:    ret <8 x i3> <i3 3, i3 3, i3 2, i3 1, i3 0, i3 -1, i3 -2, i3 -3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 2)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_3() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_3(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_3(
 ; CHECK-NEXT:    ret <8 x i3> <i3 3, i3 3, i3 2, i3 1, i3 0, i3 -1, i3 -2, i3 -3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_4() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_4(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_4(
 ; CHECK-NEXT:    ret <8 x i3> <i3 2, i3 1, i3 1, i3 0, i3 0, i3 -1, i3 -1, i3 -2>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_5() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_5(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_5(
 ; CHECK-NEXT:    ret <8 x i3> <i3 1, i3 0, i3 0, i3 0, i3 0, i3 -1, i3 -1, i3 -1>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 2)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_6() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_6(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_6(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -3, i3 0, i3 3, i3 3, i3 3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_7() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_7(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_7(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -4, i3 -4, i3 -3, i3 -2, i3 0, i3 1, i3 3, i3 3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_sat_v8i3_8() {
-; CHECK-LABEL: @test_smul_fix_sat_v8i3_8(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_sat_v8i3_8(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -3, i3 -3, i3 -2, i3 -1, i3 0, i3 0, i3 1, i3 2>
 ;
   %r = call <8 x i3> @llvm.smul.fix.sat.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 2)
   ret <8 x i3> %r
 }

llvm/test/Analysis/ConstantFolding/smul-fix.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 ;-----------------------------------------------------------------------------
 ; Simple test using scalar layout.
 ;-----------------------------------------------------------------------------
 
 declare i32 @llvm.smul.fix.i32(i32, i32, i32)
 
 define i32 @test_smul_fix_i32_0() {
-; CHECK-LABEL: @test_smul_fix_i32_0(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_i32_0(
 ; CHECK-NEXT:    ret i32 536870912
 ;
   %r = call i32 @llvm.smul.fix.i32(i32 1073741824, i32 1073741824, i32 31) ; 0.5 * 0.5
   ret i32 %r
 }
 
 ;-----------------------------------------------------------------------------
 ; More extensive tests based on vectors (basically using the scalar fold
 ; for each index).
 ;-----------------------------------------------------------------------------
 
 declare <8 x i3> @llvm.smul.fix.v8i3(<8 x i3>, <8 x i3>, i32)
 
 define <8 x i3> @test_smul_fix_v8i3_0() {
-; CHECK-LABEL: @test_smul_fix_v8i3_0(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_0(
 ; CHECK-NEXT:    ret <8 x i3> <i3 0, i3 -4, i3 0, i3 -4, i3 0, i3 -4, i3 0, i3 -4>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_1() {
-; CHECK-LABEL: @test_smul_fix_v8i3_1(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_1(
 ; CHECK-NEXT:    ret <8 x i3> <i3 0, i3 -2, i3 -4, i3 2, i3 0, i3 -2, i3 -4, i3 2>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_2() {
-; CHECK-LABEL: @test_smul_fix_v8i3_2(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_2(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -4, i3 3, i3 2, i3 1, i3 0, i3 -1, i3 -2, i3 -3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4, i3 -4>,
   i32 2)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_3() {
-; CHECK-LABEL: @test_smul_fix_v8i3_3(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_3(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -4, i3 3, i3 2, i3 1, i3 0, i3 -1, i3 -2, i3 -3>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_4() {
-; CHECK-LABEL: @test_smul_fix_v8i3_4(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_4(
 ; CHECK-NEXT:    ret <8 x i3> <i3 2, i3 1, i3 1, i3 0, i3 0, i3 -1, i3 -1, i3 -2>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_5() {
-; CHECK-LABEL: @test_smul_fix_v8i3_5(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_5(
 ; CHECK-NEXT:    ret <8 x i3> <i3 1, i3 0, i3 0, i3 0, i3 0, i3 -1, i3 -1, i3 -1>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1, i3 -1>,
   i32 2)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_6() {
-; CHECK-LABEL: @test_smul_fix_v8i3_6(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_6(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -4, i3 -1, i3 2, i3 -3, i3 0, i3 3, i3 -2, i3 1>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 0)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_7() {
-; CHECK-LABEL: @test_smul_fix_v8i3_7(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_7(
 ; CHECK-NEXT:    ret <8 x i3> <i3 2, i3 3, i3 -3, i3 -2, i3 0, i3 1, i3 3, i3 -4>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 1)
   ret <8 x i3> %r
 }
 
 define <8 x i3> @test_smul_fix_v8i3_8() {
-; CHECK-LABEL: @test_smul_fix_v8i3_8(
+; CHECK-LABEL: define {{[^@]+}}@test_smul_fix_v8i3_8(
 ; CHECK-NEXT:    ret <8 x i3> <i3 -3, i3 -3, i3 -2, i3 -1, i3 0, i3 0, i3 1, i3 2>
 ;
   %r = call <8 x i3> @llvm.smul.fix.v8i3(
   <8 x i3> <i3 -4, i3 -3, i3 -2, i3 -1, i3 0, i3 1, i3 2, i3 3>,
   <8 x i3> <i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3, i3 3>,
   i32 2)
   ret <8 x i3> %r
 }

llvm/test/Analysis/ConstantFolding/trunc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -early-cse < %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(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_01(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %x = call float @truncf(float 1.25) #0
   ret float %x
 }
 
 define float @constant_fold_trunc_f32_02() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_02(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_02(
 ; CHECK-NEXT:    ret float -1.000000e+00
 ;
   %x = call float @llvm.trunc.f32(float -1.25) #0
   ret float %x
 }
 
 define float @constant_fold_trunc_f32_03() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_03(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_03(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %x = call float @truncf(float 1.5) #0
   ret float %x
 }
 
 define float @constant_fold_trunc_f32_04() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_04(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_04(
 ; CHECK-NEXT:    ret float -1.000000e+00
 ;
   %x = call float @llvm.trunc.f32(float -1.5) #0
   ret float %x
 }
 
 define float @constant_fold_trunc_f32_05() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_05(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_05(
 ; CHECK-NEXT:    ret float 2.000000e+00
 ;
   %x = call float @truncf(float 2.75) #0
   ret float %x
 }
 
 define float @constant_fold_trunc_f32_06() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_06(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f32_06(
 ; CHECK-NEXT:    ret float -2.000000e+00
 ;
   %x = call float @llvm.trunc.f32(float -2.75) #0
   ret float %x
 }
 
 define double @constant_fold_trunc_f64_01() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_01(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_01(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %x = call double @trunc(double 1.3) #0
   ret double %x
 }
 
 define double @constant_fold_trunc_f64_02() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_02(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_02(
 ; CHECK-NEXT:    ret double -1.000000e+00
 ;
   %x = call double @llvm.trunc.f64(double -1.3) #0
   ret double %x
 }
 
 define double @constant_fold_trunc_f64_03() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_03(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_03(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %x = call double @trunc(double 1.5) #0
   ret double %x
 }
 
 define double @constant_fold_trunc_f64_04() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_04(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_04(
 ; CHECK-NEXT:    ret double -1.000000e+00
 ;
   %x = call double @llvm.trunc.f64(double -1.5) #0
   ret double %x
 }
 
 define double @constant_fold_trunc_f64_05() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_05(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_05(
 ; CHECK-NEXT:    ret double 2.000000e+00
 ;
   %x = call double @trunc(double 2.7) #0
   ret double %x
 }
 
 define double @constant_fold_trunc_f64_06() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_06(
+; CHECK-LABEL: define {{[^@]+}}@constant_fold_trunc_f64_06(
 ; CHECK-NEXT:    ret double -2.000000e+00
 ;
   %x = call double @llvm.trunc.f64(double -2.7) #0
   ret double %x
 }
 
 attributes #0 = { nounwind readnone }

llvm/test/Analysis/ConstantFolding/vector-undef-elts.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S -o - | FileCheck %s
 
 ; When both operands are undef in a lane, that lane should produce an undef result.
 
 define <3 x i8> @shl() {
-; CHECK-LABEL: @shl(
+; CHECK-LABEL: define {{[^@]+}}@shl(
 ; CHECK-NEXT:    ret <3 x i8> <i8 undef, i8 0, i8 0>
 ;
   %c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1>
   ret <3 x i8> %c
 }
 
 define <3 x i8> @and() {
-; CHECK-LABEL: @and(
+; CHECK-LABEL: define {{[^@]+}}@and(
 ; CHECK-NEXT:    ret <3 x i8> <i8 undef, i8 0, i8 undef>
 ;
   %c = and <3 x i8> <i8 undef, i8 42, i8 undef>, undef
   ret <3 x i8> %c
 }
 
 define <3 x i8> @and_commute() {
-; CHECK-LABEL: @and_commute(
+; CHECK-LABEL: define {{[^@]+}}@and_commute(
 ; CHECK-NEXT:    ret <3 x i8> <i8 0, i8 0, i8 undef>
 ;
   %c = and <3 x i8> undef, <i8 -42, i8 42, i8 undef>
   ret <3 x i8> %c
 }
 
 define <3 x i8> @or() {
-; CHECK-LABEL: @or(
+; CHECK-LABEL: define {{[^@]+}}@or(
 ; CHECK-NEXT:    ret <3 x i8> <i8 undef, i8 -1, i8 undef>
 ;
   %c = or <3 x i8> <i8 undef, i8 42, i8 undef>, undef
   ret <3 x i8> %c
 }
 
 define <3 x i8> @or_commute() {
-; CHECK-LABEL: @or_commute(
+; CHECK-LABEL: define {{[^@]+}}@or_commute(
 ; CHECK-NEXT:    ret <3 x i8> <i8 -1, i8 -1, i8 undef>
 ;
   %c = or <3 x i8> undef, <i8 -42, i8 42, i8 undef>
   ret <3 x i8> %c
 }
 
 define <3 x float> @fadd() {
-; CHECK-LABEL: @fadd(
+; CHECK-LABEL: define {{[^@]+}}@fadd(
 ; CHECK-NEXT:    ret <3 x float> <float undef, float 0x7FF8000000000000, float undef>
 ;
   %c = fadd <3 x float> <float undef, float 42.0, float undef>, undef
   ret <3 x float> %c
 }
 
 define <3 x float> @fadd_commute() {
-; CHECK-LABEL: @fadd_commute(
+; CHECK-LABEL: define {{[^@]+}}@fadd_commute(
 ; CHECK-NEXT:    ret <3 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000, float undef>
 ;
   %c = fadd <3 x float> undef, <float -42.0, float 42.0, float undef>
   ret <3 x float> %c
 }
 
 define <4 x i32> @shuffle_of_undefs(<4 x i32> %v1, <4 x i32> %v2) {
-; CHECK-LABEL: @shuffle_of_undefs(
+; CHECK-LABEL: define {{[^@]+}}@shuffle_of_undefs(
 ; CHECK-NEXT:    ret <4 x i32> undef
 ;
   %r = shufflevector <4 x i32> undef, <4 x i32> undef, <4 x i32> <i32 5, i32 1, i32 2, i32 3>
   ret <4 x i32> %r
 }
 

llvm/test/Analysis/TypeBasedAliasAnalysis/memcpyopt.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -tbaa -basicaa -memcpyopt -instcombine < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 ; The second memcpy is redundant and can be deleted. There's an intervening store, but
 ; it has a TBAA tag which declares that it is unrelated.
 
 define void @foo(i8* nocapture %p, i8* nocapture %q, i8* nocapture %s) nounwind {
-; CHECK: @foo
-; CHECK-NEXT: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(16) %p, i8* nonnull align 1 dereferenceable(16) %q, i64 16, i1 false), !tbaa !0
-; CHECK-NEXT: store i8 2, i8* %s, align 1, !tbaa [[TAGA:!.*]]
-; CHECK-NEXT: ret void
+; CHECK-LABEL: define {{[^@]+}}@foo(
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 dereferenceable(16) [[P:%.*]], i8* nonnull align 1 dereferenceable(16) [[Q:%.*]], i64 16, i1 false), !tbaa !0
+; CHECK-NEXT:    store i8 2, i8* [[S:%.*]], align 1, !tbaa !3
+; CHECK-NEXT:    ret void
+;
   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %p, i8* %q, i64 16, i1 false), !tbaa !2
   store i8 2, i8* %s, align 1, !tbaa !1
   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %q, i8* %p, i64 16, i1 false), !tbaa !2
   ret void
 }
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 
 ; CHECK: [[TAGA]] = !{[[TYPEA:!.*]], [[TYPEA]], i64 0}
 ; CHECK: [[TYPEA]] = !{!"A", !{{.*}}}
 !0 = !{!"tbaa root"}
 !1 = !{!3, !3, i64 0}
 !2 = !{!4, !4, i64 0}
 !3 = !{!"A", !0}
 !4 = !{!"B", !0}

llvm/test/Analysis/ValueTracking/assume.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define i32 @assume_add(i32 %a, i32 %b) {
-; CHECK-LABEL: @assume_add(
+; CHECK-LABEL: define {{[^@]+}}@assume_add(
 ; CHECK-NEXT:    [[T1:%.*]] = add i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[LAST_TWO_DIGITS:%.*]] = and i32 [[T1]], 3
 ; CHECK-NEXT:    [[T2:%.*]] = icmp eq i32 [[LAST_TWO_DIGITS]], 0
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[T2]])
 ; CHECK-NEXT:    [[T3:%.*]] = or i32 [[T1]], 3
 ; CHECK-NEXT:    ret i32 [[T3]]
 ;
   %t1 = add i32 %a, %b
   %last_two_digits = and i32 %t1, 3
   %t2 = icmp eq i32 %last_two_digits, 0
   call void @llvm.assume(i1 %t2)
   %t3 = add i32 %t1, 3
   ret i32 %t3
 }
 
 
 define void @assume_not() {
-; CHECK-LABEL: @assume_not(
+; CHECK-LABEL: define {{[^@]+}}@assume_not(
+; CHECK-NEXT:  entry-block:
+; CHECK-NEXT:    [[TMP0:%.*]] = call i1 @get_val()
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[TMP0]], true
+; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP1]])
+; CHECK-NEXT:    ret void
+;
 entry-block:
   %0 = call i1 @get_val()
-; CHECK: call void @llvm.assume
   %1 = xor i1 %0, true
   call void @llvm.assume(i1 %1)
   ret void
 }
 
 declare i1 @get_val()
 declare void @llvm.assume(i1)

llvm/test/Analysis/ValueTracking/known-nonnull-at.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instsimplify < %s | FileCheck %s
 
 declare void @bar(i8* %a, i8* nonnull %b)
 
 ; 'y' must be nonnull.
 
 define i1 @caller1(i8* %x, i8* %y) {
-; CHECK-LABEL: @caller1(
-; CHECK-NEXT:    call void @bar(i8* %x, i8* %y)
+; CHECK-LABEL: define {{[^@]+}}@caller1(
+; CHECK-NEXT:    call void @bar(i8* [[X:%.*]], i8* [[Y:%.*]])
 ; CHECK-NEXT:    ret i1 false
 ;
   call void @bar(i8* %x, i8* %y)
   %null_check = icmp eq i8* %y, null
   ret i1 %null_check
 }
 
 ; Don't know anything about 'y'.
 
 define i1 @caller2(i8* %x, i8* %y) {
-; CHECK-LABEL: @caller2(
-; CHECK-NEXT:    call void @bar(i8* %y, i8* %x)
-; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* %y, null
+; CHECK-LABEL: define {{[^@]+}}@caller2(
+; CHECK-NEXT:    call void @bar(i8* [[Y:%.*]], i8* [[X:%.*]])
+; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* [[Y]], null
 ; CHECK-NEXT:    ret i1 [[NULL_CHECK]]
 ;
   call void @bar(i8* %y, i8* %x)
   %null_check = icmp eq i8* %y, null
   ret i1 %null_check
 }
 
 ; 'y' must be nonnull.
 
 define i1 @caller3(i8* %x, i8* %y) {
-; CHECK-LABEL: @caller3(
-; CHECK-NEXT:    call void @bar(i8* %x, i8* %y)
+; CHECK-LABEL: define {{[^@]+}}@caller3(
+; CHECK-NEXT:    call void @bar(i8* [[X:%.*]], i8* [[Y:%.*]])
 ; CHECK-NEXT:    ret i1 true
 ;
   call void @bar(i8* %x, i8* %y)
   %null_check = icmp ne i8* %y, null
   ret i1 %null_check
 }
 
 ; FIXME: The call is guaranteed to execute, so 'y' must be nonnull throughout.
 
 define i1 @caller4(i8* %x, i8* %y) {
-; CHECK-LABEL: @caller4(
-; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp ne i8* %y, null
-; CHECK-NEXT:    call void @bar(i8* %x, i8* %y)
+; CHECK-LABEL: define {{[^@]+}}@caller4(
+; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp ne i8* [[Y:%.*]], null
+; CHECK-NEXT:    call void @bar(i8* [[X:%.*]], i8* [[Y]])
 ; CHECK-NEXT:    ret i1 [[NULL_CHECK]]
 ;
   %null_check = icmp ne i8* %y, null
   call void @bar(i8* %x, i8* %y)
   ret i1 %null_check
 }
 
 ; The call to bar() does not dominate the null check, so no change.
 
 define i1 @caller5(i8* %x, i8* %y) {
-; CHECK-LABEL: @caller5(
-; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* %y, null
-; CHECK-NEXT:    br i1 [[NULL_CHECK]], label %t, label %f
+; CHECK-LABEL: define {{[^@]+}}@caller5(
+; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* [[Y:%.*]], null
+; CHECK-NEXT:    br i1 [[NULL_CHECK]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       t:
 ; CHECK-NEXT:    ret i1 [[NULL_CHECK]]
 ; CHECK:       f:
-; CHECK-NEXT:    call void @bar(i8* %x, i8* %y)
+; CHECK-NEXT:    call void @bar(i8* [[X:%.*]], i8* [[Y]])
 ; CHECK-NEXT:    ret i1 [[NULL_CHECK]]
 ;
   %null_check = icmp eq i8* %y, null
   br i1 %null_check, label %t, label %f
 t:
   ret i1 %null_check
 f:
   call void @bar(i8* %x, i8* %y)
   ret i1 %null_check
 }
 
 ; Make sure that an invoke works similarly to a call.
 
 declare i32 @esfp(...)
 
 define i1 @caller6(i8* %x, i8* %y) personality i8* bitcast (i32 (...)* @esfp to i8*){
-; CHECK-LABEL: @caller6(
-; CHECK-NEXT:    invoke void @bar(i8* %x, i8* nonnull %y)
-; CHECK-NEXT:    to label %cont unwind label %exc
+; CHECK-LABEL: define {{[^@]+}}@caller6(
+; CHECK-NEXT:    invoke void @bar(i8* [[X:%.*]], i8* nonnull [[Y:%.*]])
+; CHECK-NEXT:    to label [[CONT:%.*]] unwind label [[EXC:%.*]]
 ; CHECK:       cont:
 ; CHECK-NEXT:    ret i1 false
+; CHECK:       exc:
+; CHECK-NEXT:    [[LP:%.*]] = landingpad { i8*, i32 }
+; CHECK-NEXT:    filter [0 x i8*] zeroinitializer
+; CHECK-NEXT:    unreachable
 ;
   invoke void @bar(i8* %x, i8* nonnull %y)
-    to label %cont unwind label %exc
 
 cont:
   %null_check = icmp eq i8* %y, null
   ret i1 %null_check
 
 exc:
   %lp = landingpad { i8*, i32 }
-    filter [0 x i8*] zeroinitializer
   unreachable
 }
 
 declare i8* @returningPtr(i8* returned %p)
 
 define i1 @nonnullReturnTest(i8* nonnull %x) {
-; CHECK-LABEL: @nonnullReturnTest(
-; CHECK-NEXT:    %x2 = call i8* @returningPtr(i8* %x)
+; CHECK-LABEL: define {{[^@]+}}@nonnullReturnTest(
+; CHECK-NEXT:    [[X2:%.*]] = call i8* @returningPtr(i8* [[X:%.*]])
 ; CHECK-NEXT:    ret i1 false
+;
   %x2 = call i8* @returningPtr(i8* %x)
   %null_check = icmp eq i8* %x2, null
   ret i1 %null_check
 }
 
 define i1 @unknownReturnTest(i8* %x) {
-; CHECK-LABEL: @unknownReturnTest(
-; CHECK-NEXT:    %x2 = call i8* @returningPtr(i8* %x)
-; CHECK-NEXT:    %null_check = icmp eq i8* %x2, null
-; CHECK-NEXT:    ret i1 %null_check
+; CHECK-LABEL: define {{[^@]+}}@unknownReturnTest(
+; CHECK-NEXT:    [[X2:%.*]] = call i8* @returningPtr(i8* [[X:%.*]])
+; CHECK-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* [[X2]], null
+; CHECK-NEXT:    ret i1 [[NULL_CHECK]]
+;
   %x2 = call i8* @returningPtr(i8* %x)
   %null_check = icmp eq i8* %x2, null
   ret i1 %null_check
 }
 

llvm/test/Analysis/ValueTracking/known-signbit-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 ; Result of left shifting a non-negative integer
 ; with nsw flag should also be non-negative
 define i1 @test_shift_nonnegative(i32 %a) {
-; CHECK-LABEL: @test_shift_nonnegative(
+; CHECK-LABEL: define {{[^@]+}}@test_shift_nonnegative(
 ; CHECK-NEXT:    ret i1 true
 ;
   %b = lshr i32 %a, 2
   %shift = shl nsw i32 %b, 3
   %cmp = icmp sge i32 %shift, 0
   ret i1 %cmp
 }
 
 ; Result of left shifting a negative integer with
 ; nsw flag should also be negative
 define i1 @test_shift_negative(i32 %a, i32 %b) {
-; CHECK-LABEL: @test_shift_negative(
+; CHECK-LABEL: define {{[^@]+}}@test_shift_negative(
 ; CHECK-NEXT:    ret i1 true
 ;
   %c = or i32 %a, -2147483648
   %d = and i32 %b, 7
   %shift = shl nsw i32 %c, %d
   %cmp = icmp slt i32 %shift, 0
   ret i1 %cmp
 }
 
 ; If sign bit is a known zero, it cannot be a known one.
 ; This test should not crash opt. The shift produces poison.
 define i32 @test_no_sign_bit_conflict1(i1 %b) {
-; CHECK-LABEL: @test_no_sign_bit_conflict1(
+; CHECK-LABEL: define {{[^@]+}}@test_no_sign_bit_conflict1(
 ; CHECK-NEXT:    ret i32 0
 ;
   %sel = select i1 %b, i32 8193, i32 8192
   %mul = shl nsw i32 %sel, 18
   ret i32 %mul
 }
 
 ; If sign bit is a known one, it cannot be a known zero.
 ; This test should not crash opt. The shift produces poison.
 define i32 @test_no_sign_bit_conflict2(i1 %b) {
-; CHECK-LABEL: @test_no_sign_bit_conflict2(
+; CHECK-LABEL: define {{[^@]+}}@test_no_sign_bit_conflict2(
 ; CHECK-NEXT:    ret i32 0
 ;
   %sel = select i1 %b, i32 -8193, i32 -8194
   %mul = shl nsw i32 %sel, 18
   ret i32 %mul
 }

llvm/test/Analysis/ValueTracking/knownzero-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instsimplify -S < %s | FileCheck %s
 
 define i1 @test(i8 %p, i8* %pq) {
-; CHECK-LABEL: @test(
+; CHECK-LABEL: define {{[^@]+}}@test(
 ; CHECK-NEXT:    ret i1 false
 ;
   %q = load i8, i8* %pq, !range !0 ; %q is known nonzero; no known bits
   %1 = or i8 %p, 2                 ; %1[1] = 1
   %2 = and i8 %1, 254              ; %2[0] = 0, %2[1] = 1
   %A = lshr i8 %2, 1               ; We should know that %A is nonzero.
   %x = icmp eq i8 %A, 0
   ret i1 %x
 }
 
 !0 = !{ i8 1, i8 5 }
 
 define i32 @shl_shl(i32 %A) {
-; CHECK-LABEL: @shl_shl(
+; CHECK-LABEL: define {{[^@]+}}@shl_shl(
 ; CHECK-NEXT:    ret i32 0
 ;
   %B = shl i32 %A, 6
   %C = shl i32 %B, 28
   ret i32 %C
 }
 
 define <2 x i33> @shl_shl_splat_vec(<2 x i33> %A) {
-; CHECK-LABEL: @shl_shl_splat_vec(
+; CHECK-LABEL: define {{[^@]+}}@shl_shl_splat_vec(
 ; CHECK-NEXT:    ret <2 x i33> zeroinitializer
 ;
   %B = shl <2 x i33> %A, <i33 5, i33 5>
   %C = shl <2 x i33> %B, <i33 28, i33 28>
   ret <2 x i33> %C
 }
 
 ; FIXME
 
 define <2 x i33> @shl_shl_vec(<2 x i33> %A) {
-; CHECK-LABEL: @shl_shl_vec(
-; CHECK-NEXT:    [[B:%.*]] = shl <2 x i33> %A, <i33 6, i33 5>
+; CHECK-LABEL: define {{[^@]+}}@shl_shl_vec(
+; CHECK-NEXT:    [[B:%.*]] = shl <2 x i33> [[A:%.*]], <i33 6, i33 5>
 ; CHECK-NEXT:    [[C:%.*]] = shl <2 x i33> [[B]], <i33 27, i33 28>
 ; CHECK-NEXT:    ret <2 x i33> [[C]]
 ;
   %B = shl <2 x i33> %A, <i33 6, i33 5>
   %C = shl <2 x i33> %B, <i33 27, i33 28>
   ret <2 x i33> %C
 }
 
 define i232 @lshr_lshr(i232 %A) {
-; CHECK-LABEL: @lshr_lshr(
+; CHECK-LABEL: define {{[^@]+}}@lshr_lshr(
 ; CHECK-NEXT:    ret i232 0
 ;
   %B = lshr i232 %A, 231
   %C = lshr i232 %B, 1
   ret i232 %C
 }
 
 define <2 x i32> @lshr_lshr_splat_vec(<2 x i32> %A) {
-; CHECK-LABEL: @lshr_lshr_splat_vec(
+; CHECK-LABEL: define {{[^@]+}}@lshr_lshr_splat_vec(
 ; CHECK-NEXT:    ret <2 x i32> zeroinitializer
 ;
   %B = lshr <2 x i32> %A, <i32 28, i32 28>
   %C = lshr <2 x i32> %B, <i32 4, i32 4>
   ret <2 x i32> %C
 }
 
 define <2 x i32> @lshr_lshr_vec(<2 x i32> %A) {
-; CHECK-LABEL: @lshr_lshr_vec(
+; CHECK-LABEL: define {{[^@]+}}@lshr_lshr_vec(
 ; CHECK-NEXT:    ret <2 x i32> zeroinitializer
 ;
   %B = lshr <2 x i32> %A, <i32 29, i32 28>
   %C = lshr <2 x i32> %B, <i32 4, i32 5>
   ret <2 x i32> %C
 }
 

llvm/test/Analysis/ValueTracking/non-negative-phi-bits.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine < %s -S | FileCheck %s
 
 define void @test() #0 {
-; CHECK-LABEL: @test(
+; CHECK-LABEL: define {{[^@]+}}@test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[INDVARS_IV:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVARS_IV_NEXT:%.*]], [[FOR_BODY]] ]
 ; CHECK-NEXT:    [[INDVARS_IV_NEXT]] = add nuw nsw i64 [[INDVARS_IV]], 1
 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp ult i64 [[INDVARS_IV_NEXT]], 40
 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_END:%.*]], label [[FOR_BODY]]
 ; CHECK:       for.end:

llvm/test/Analysis/ValueTracking/numsignbits-from-assume.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 define i32 @computeNumSignBits_add1(i32 %in) {
-; CHECK-LABEL: @computeNumSignBits_add1(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_add1(
 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[IN:%.*]], 1
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[ADD]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[ADD]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %add = add i32 %in, 1
   %cond = icmp ule i32 %add, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %add, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_add2(i32 %in1, i32 %in2) {
-; CHECK-LABEL: @computeNumSignBits_add2(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_add2(
 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[IN1:%.*]], [[IN2:%.*]]
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[ADD]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[ADD]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %add = add i32 %in1, %in2
   %cond = icmp ule i32 %add, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %add, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_sub1(i32 %in) {
-; CHECK-LABEL: @computeNumSignBits_sub1(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_sub1(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i32 1, [[IN:%.*]]
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[SUB]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[SUB]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %sub = sub i32 1, %in
   %cond = icmp ule i32 %sub, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %sub, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_sub2(i32 %in) {
-; CHECK-LABEL: @computeNumSignBits_sub2(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_sub2(
 ; CHECK-NEXT:    [[SUB:%.*]] = add i32 [[IN:%.*]], -1
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[SUB]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[SUB]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %sub = sub i32 %in, 1
   %cond = icmp ule i32 %sub, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %sub, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_sub3(i32 %in1, i32 %in2) {
-; CHECK-LABEL: @computeNumSignBits_sub3(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_sub3(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i32 [[IN1:%.*]], [[IN2:%.*]]
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[SUB]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[SUB]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %sub = sub i32 %in1, %in2
   %cond = icmp ule i32 %sub, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %sub, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_mul(i32 %in1, i32 %in2) {
-; CHECK-LABEL: @computeNumSignBits_mul(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_mul(
 ; CHECK-NEXT:    [[MUL:%.*]] = mul i32 [[IN1:%.*]], [[IN2:%.*]]
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[MUL]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[MUL]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %mul = mul i32 %in1, %in2
   %cond = icmp ule i32 %mul, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %mul, 3
   ret i32 %sh
 }
 
 define i32 @computeNumSignBits_select(i32 %in, i1 %s) {
-; CHECK-LABEL: @computeNumSignBits_select(
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_select(
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[S:%.*]], i32 [[IN:%.*]], i32 1
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ult i32 [[SEL]], 43
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND]])
 ; CHECK-NEXT:    [[SH:%.*]] = shl nuw nsw i32 [[SEL]], 3
 ; CHECK-NEXT:    ret i32 [[SH]]
 ;
   %sel = select i1 %s, i32 %in, i32 1
   %cond = icmp ule i32 %sel, 42
   call void @llvm.assume(i1 %cond)
   %sh = shl i32 %sel, 3
   ret i32 %sh
 }
 
 declare void @llvm.assume(i1)

llvm/test/Analysis/ValueTracking/select-pattern.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -simplifycfg < %s -S | FileCheck %s
 
 ; The dead code would cause a select that had itself
 ; as an operand to be analyzed. This would then cause
 ; infinite recursion and eventual crash.
 
 define void @PR36045(i1 %t, i32* %b) {
-; CHECK-LABEL: @PR36045(
+; CHECK-LABEL: define {{[^@]+}}@PR36045(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = xor i1 [[T:%.*]], true
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP0]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br i1 %t, label %if, label %end
 

llvm/test/Analysis/ValueTracking/signbits-extract-elt.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; If computeKnownBits can do a simple look-through for extractelement
 ; then instsimplify will know that %elt1 is non-negative at icmp.
 define i1 @computeKnownBits_look_through_extractelt(<2 x i8> %vecin) {
-; CHECK-LABEL: @computeKnownBits_look_through_extractelt(
+; CHECK-LABEL: define {{[^@]+}}@computeKnownBits_look_through_extractelt(
 ; CHECK-NEXT:    ret i1 false
 ;
   %vec = zext <2 x i8> %vecin to <2 x i32>
   %elt1 = extractelement <2 x i32> %vec, i32 1
   %bool = icmp slt i32 %elt1, 0
   ret i1 %bool
 }
 
 ; If computeNumSignBits can do a simple look-through for extractelement
 ; then instsimplify will remove the ashr.
 define i32 @computeNumSignBits_look_through_extractelt(<2 x i1> %vecin) {
-; CHECK-LABEL: @computeNumSignBits_look_through_extractelt(
-; CHECK-NEXT:    [[VEC:%.*]] = sext <2 x i1> [[VEC:%.*]]in to <2 x i32>
+; CHECK-LABEL: define {{[^@]+}}@computeNumSignBits_look_through_extractelt(
+; CHECK-NEXT:    [[VEC:%.*]] = sext <2 x i1> [[VECIN:%.*]] to <2 x i32>
 ; CHECK-NEXT:    [[ELT0:%.*]] = extractelement <2 x i32> [[VEC]], i32 0
 ; CHECK-NEXT:    ret i32 [[ELT0]]
 ;
   %vec = sext <2 x i1> %vecin to <2 x i32>
   %elt0 = extractelement <2 x i32> %vec, i32 0
   %ashr = ashr i32 %elt0, 5
   ret i32 %ashr
 }