test function name order correction

Author: cezarbbb

tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-2.rs

@@ -60,10 +60,10 @@ pub fn test1(a: *const u8) {
     // missing-NOT: __stack_chk_fail
 }
 
-// test3: array [4 x i8]
-// CHECK-LABEL: test3{{:|\[}}
+// test2: array [4 x i8]
+// CHECK-LABEL: test2{{:|\[}}
 #[no_mangle]
-pub fn test3(a: *const u8) {
+pub fn test2(a: *const u8) {
     let mut buf: [u8; 4] = [0; 4];
 
     unsafe {
@@ -77,10 +77,10 @@ pub fn test3(a: *const u8) {
     // missing-NOT: __stack_chk_fail
 }
 
-// test5: no arrays / no nested arrays
-// CHECK-LABEL: test5{{:|\[}}
+// test3: no arrays / no nested arrays
+// CHECK-LABEL: test3{{:|\[}}
 #[no_mangle]
-pub fn test5(a: *const u8) {
+pub fn test3(a: *const u8) {
     unsafe {
         printf(STR.as_ptr(), a);
     }
@@ -91,10 +91,10 @@ pub fn test5(a: *const u8) {
     // missing-NOT: __stack_chk_fail
 }
 
-// test6: Address-of local taken (j = &a)
-// CHECK-LABEL: test6{{:|\[}}
+// test4: Address-of local taken (j = &a)
+// CHECK-LABEL: test4{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test6() {
+pub unsafe extern "C" fn test4() {
     let mut a: i32 = 0;
 
     let mut j: *mut i32 = std::ptr::null_mut();
@@ -111,10 +111,10 @@ pub unsafe extern "C" fn test6() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test7: PtrToInt Cast
-// CHECK-LABEL: test7{{:|\[}}
+// test5: PtrToInt Cast
+// CHECK-LABEL: test5{{:|\[}}
 #[no_mangle]
-pub fn test7(a: i32) {
+pub fn test5(a: i32) {
     let ptr_val: usize = &a as *const i32 as usize;
 
     unsafe {
@@ -127,10 +127,10 @@ pub fn test7(a: i32) {
     // missing-NOT: __stack_chk_fail
 }
 
-// test8: Passing addr-of to function call
-// CHECK-LABEL: test8{{:|\[}}
+// test6: Passing addr-of to function call
+// CHECK-LABEL: test6{{:|\[}}
 #[no_mangle]
-pub fn test8(mut b: i32) {
+pub fn test6(mut b: i32) {
     unsafe {
         funcall(&mut b as *mut i32);
     }
@@ -141,10 +141,10 @@ pub fn test8(mut b: i32) {
     // missing-NOT: __stack_chk_fail
 }
 
-// test9: Addr-of in select instruction
-// CHECK-LABEL: test9{{:|\[}}
+// test7: Addr-of in select instruction
+// CHECK-LABEL: test7{{:|\[}}
 #[no_mangle]
-pub fn test9() {
+pub fn test7() {
     let x: f64;
 
     unsafe {
@@ -162,10 +162,10 @@ pub fn test9() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test10: Addr-of in phi instruction
-// CHECK-LABEL: test10{{:|\[}}
+// test8: Addr-of in phi instruction
+// CHECK-LABEL: test8{{:|\[}}
 #[no_mangle]
-pub fn test10() {
+pub fn test8() {
     let mut _x: f64;
 
     unsafe {
@@ -195,10 +195,10 @@ pub fn test10() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test11: Addr-of struct element(GEP followed by store)
-// CHECK-LABEL: test11{{:|\[}}
+// test9: Addr-of struct element(GEP followed by store)
+// CHECK-LABEL: test9{{:|\[}}
 #[no_mangle]
-pub fn test11() {
+pub fn test9() {
     let mut c = Pair { a: 0, b: 0 };
     let b: *mut i32;
 
@@ -216,10 +216,10 @@ pub fn test11() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test12: Addr-of struct element, GEP followed by ptrtoint
-// CHECK-LABEL: test12{{:|\[}}
+// test10: Addr-of struct element, GEP followed by ptrtoint
+// CHECK-LABEL: test10{{:|\[}}
 #[no_mangle]
-pub fn test12() {
+pub fn test10() {
     let mut c = Pair { a: 0, b: 0 };
 
     unsafe {
@@ -236,10 +236,10 @@ pub fn test12() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test13: Addr-of struct element, GEP followed by callinst
-// CHECK-LABEL: test13{{:|\[}}
+// test11: Addr-of struct element, GEP followed by callinst
+// CHECK-LABEL: test11{{:|\[}}
 #[no_mangle]
-pub fn test13() {
+pub fn test11() {
     let mut c = Pair { a: 0, b: 0 };
 
     unsafe {
@@ -254,10 +254,10 @@ pub fn test13() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test14: Addr-of a local, optimized into a GEP (e.g., &a - 12)
-// CHECK-LABEL: test14{{:|\[}}
+// test12: Addr-of a local, optimized into a GEP (e.g., &a - 12)
+// CHECK-LABEL: test12{{:|\[}}
 #[no_mangle]
-pub fn test14() {
+pub fn test12() {
     let mut a: i32 = 0;
 
     unsafe {
@@ -272,11 +272,11 @@ pub fn test14() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test15: Addr-of a local cast to a ptr of a different type
+// test13: Addr-of a local cast to a ptr of a different type
 // (e.g., int a; ... ; ptr b = &a;)
-// CHECK-LABEL: test15{{:|\[}}
+// CHECK-LABEL: test13{{:|\[}}
 #[no_mangle]
-pub fn test15() {
+pub fn test13() {
     let mut a: i32 = 0;
 
     unsafe {
@@ -294,11 +294,11 @@ pub fn test15() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test16: Addr-of a local cast to a ptr of a different type (optimized)
+// test14: Addr-of a local cast to a ptr of a different type (optimized)
 // (e.g., int a; ... ; ptr b = &a;)
-// CHECK-LABEL: test16{{:|\[}}
+// CHECK-LABEL: test14{{:|\[}}
 #[no_mangle]
-pub fn test16() {
+pub fn test14() {
     let a: i32 = 0;
     unsafe {
         funfloat((&a as *const i32).cast::<f64>() as *mut f64);
@@ -310,10 +310,10 @@ pub fn test16() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test18: Addr-of a variable passed into an invoke instruction
-// CHECK-LABEL: test18{{:|\[}}
+// test15: Addr-of a variable passed into an invoke instruction
+// CHECK-LABEL: test15{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test18() -> i32 {
+pub unsafe extern "C" fn test15() -> i32 {
     let mut a: i32 = 0;
 
     except(&mut a as *mut i32);
@@ -326,11 +326,11 @@ pub unsafe extern "C" fn test18() -> i32 {
     // missing-NOT: __stack_chk_fail
 }
 
-// test19: Addr-of a struct element passed into an invoke instruction
+// test16: Addr-of a struct element passed into an invoke instruction
 // (GEP followed by an invoke)
-// CHECK-LABEL: test19{{:|\[}}
+// CHECK-LABEL: test16{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test19() -> i32 {
+pub unsafe extern "C" fn test16() -> i32 {
     let mut c = Pair { a: 0, b: 0 };
 
     except(&mut c.a as *mut i32);
@@ -343,10 +343,10 @@ pub unsafe extern "C" fn test19() -> i32 {
     // missing-NOT: __stack_chk_fail
 }
 
-// test20: Addr-of a pointer
-// CHECK-LABEL: test20{{:|\[}}
+// test17: Addr-of a pointer
+// CHECK-LABEL: test17{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test20() {
+pub unsafe extern "C" fn test17() {
     let mut a: *mut i32 = getp();
 
     let mut _b: *mut *mut i32 = std::ptr::null_mut();
@@ -363,10 +363,10 @@ pub unsafe extern "C" fn test20() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test21: Addr-of a casted pointer
-// CHECK-LABEL: test21{{:|\[}}
+// test18: Addr-of a casted pointer
+// CHECK-LABEL: test18{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test21() {
+pub unsafe extern "C" fn test18() {
     let mut a: *mut i32 = getp();
 
     let mut _b: *mut *mut i32 = std::ptr::null_mut();
@@ -383,10 +383,10 @@ pub unsafe extern "C" fn test21() {
     // missing-NOT: __stack_chk_fail
 }
 
-// test25: array of [4 x i32]
-// CHECK-LABEL: test25{{:|\[}}
+// test19: array of [4 x i32]
+// CHECK-LABEL: test19{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test25() -> i32 {
+pub unsafe extern "C" fn test19() -> i32 {
     let a: [i32; 4] = [0; 4];
 
     let _whole = std::ptr::read_volatile(&a as *const _); // avoid array a from optimization
@@ -399,12 +399,12 @@ pub unsafe extern "C" fn test25() -> i32 {
     // missing-NOT: __stack_chk_fail
 }
 
-// test26: Nested structure, no arrays, no address-of expressions
+// test20: Nested structure, no arrays, no address-of expressions
 // Verify that the resulting gep-of-gep does not incorrectly trigger
 // a stack protector
-// CHECK-LABEL: test26{{:|\[}}
+// CHECK-LABEL: test20{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test26() {
+pub unsafe extern "C" fn test20() {
     let c = Nest { first: Pair { a: 10, b: 11 }, second: Pair { a: 20, b: 21 } };
 
     let whole: Nest = std::ptr::read_volatile(&c);
@@ -416,14 +416,14 @@ pub unsafe extern "C" fn test26() {
     // strong-NOT: __stack_chk_fail
 }
 
-// test27: Address-of a structure taken in a function with a loop where
+// test21: Address-of a structure taken in a function with a loop where
 // the alloca is an incoming value to a PHI node and a use of that PHI
 // node is also an incoming value
 // Verify that the address-of analysis does not get stuck in infinite
 // recursion when chasing the alloca through the PHI nodes
-// CHECK-LABEL: test27{{:|\[}}
+// CHECK-LABEL: test21{{:|\[}}
 #[no_mangle]
-pub unsafe extern "C" fn test27() -> i32 {
+pub unsafe extern "C" fn test21() -> i32 {
     let mut tmp: *mut u8 = std::ptr::null_mut();
     let tmp_ptr: *mut *mut u8 = &mut tmp;