seperated hotpatch test types, improved tests

Author: nebulark

tests/run-make/hotpatch-unaffected/lib.rs

@@ -0,0 +1,25 @@
+// hotpatch has two requirements:
+// 1. the first instruction of a functin must be at least two bytes long
+// 2. there must not be a jump to the first instruction
+
+// the functions in this file already fulfill the conditions so hotpatch should not affect them
+
+// --------------------------------------------------------------------------------------------
+
+#[no_mangle]
+#[inline(never)]
+pub fn return_42() -> i32 {
+    42
+}
+
+// --------------------------------------------------------------------------------------------
+// This tailcall does not jump to the first instruction so hotpatch should leave it unaffected
+
+#[no_mangle]
+pub fn tailcall(a: i32) -> i32 {
+    if a > 10000 {
+        return a;
+    }
+
+    if a % 2 == 0 { tailcall(a / 2) } else { tailcall(a * 3 + 1) }
+}

tests/run-make/hotpatch-unaffected/rmake.rs

@@ -0,0 +1,53 @@
+// Check if hotpatch leaves the functions that are already hotpatchable untouched
+
+//@ revisions: x32 x64
+//@[x32] only-x86
+//@[x64] only-x86_64
+// Reason: hotpatch is only implemented for X86
+
+use run_make_support::{assertion_helpers, llvm, rustc};
+
+fn main() {
+    let disassemble_symbols_arg = "--disassemble-symbols=return_42,tailcall";
+
+    rustc().input("lib.rs").crate_name("regular").crate_type("lib").opt_level("3").run();
+
+    let regular_dump = llvm::llvm_objdump()
+        .arg(disassemble_symbols_arg)
+        .input("libregular.rlib")
+        .run()
+        .stdout_utf8();
+
+    rustc()
+        .input("lib.rs")
+        .crate_name("hotpatch")
+        .crate_type("lib")
+        .opt_level("3")
+        .arg("-Zhotpatch")
+        .run();
+
+    let hotpatch_dump = llvm::llvm_objdump()
+        .arg(disassemble_symbols_arg)
+        .input("libhotpatch.rlib")
+        .run()
+        .stdout_utf8();
+
+    {
+        let mut lines_regular = regular_dump.lines();
+        let mut lines_hotpatch = hotpatch_dump.lines();
+
+        loop {
+            match (lines_regular.next(), lines_hotpatch.next()) {
+                (None, None) => break,
+                (Some(r), Some(h)) => {
+                    if r.contains("libregular.rlib") {
+                        assertion_helpers::assert_contains(h, "libhotpatch.rlib")
+                    } else {
+                        assertion_helpers::assert_equals(&r, &h)
+                    }
+                }
+                _ => panic!("the files should have equal length"),
+            }
+        }
+    }
+}

tests/run-make/hotpatch/lib.rs

@@ -8,7 +8,7 @@
 //  so its important to check that those are
 // unneccessarily affected
 
-// ------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------
 
 // regularly this tailcall would jump to the first instruction the function
 // CHECK-LABEL: <tailcall_fn>:
@@ -27,38 +27,21 @@ pub fn tailcall_fn() {
     }
 }
 
-// ------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------
 
-// empty_fn just returns. Note that 'ret' is a single byte instruction, but hotpatch requires a two
-// or more byte instructions to be at the start of the functions.
+// empty_fn just returns. Note that 'ret' is a single byte instruction, but hotpatch requires
+// a two or more byte instructions to be at the start of the functions.
 // Preferably we would also tests a different single byte instruction,
 // but I was not able to make rustc emit anything but 'ret'.
 
+// check that if the first instruction is just a single byte, so our test is valid
 // CHECK-LABEL: <empty_fn>:
-// CHECK-NEXT: ret
+// CHECK-NOT: 0: {{[0-9a-f][0-9a-f]}} {{[0-9a-f][0-9a-f]}} {{.*}}
 
+// check that the first instruction is at least 2 bytes long
 // HOTPATCH-LABEL: <empty_fn>:
-// HOTPATCH-NOT: ret
-// HOTPATCH: ret
+// HOTPATCH-NEXT: 0: {{[0-9a-f][0-9a-f]}} {{[0-9a-f][0-9a-f]}} {{.*}}
 
 #[no_mangle]
 #[inline(never)]
 pub fn empty_fn() {}
-
-// ------------------------------------------------------------------------------------------------
-
-// return_42 should not be affected by hotpatch
-
-// CHECK-LABEL: <return_42>:
-// CHECK-NEXT: 0:
-// CHECK-NEXT: ret
-
-// HOTPATCH-LABEL: <return_42>:
-// HOTPATCH-NEXT: 0:
-// HOTPATCH-NEXT: ret
-
-#[no_mangle]
-#[inline(never)]
-pub fn return_42() -> i32 {
-    42
-}

tests/run-make/hotpatch/rmake.rs

@@ -7,18 +7,20 @@
 //@[x64] only-x86_64
 // Reason: hotpatch is only implemented for X86
 
-use run_make_support::{llvm, rfs, rustc};
+use run_make_support::{llvm, rustc};
 
 fn main() {
+    let disassemble_symbols_arg = "--disassemble-symbols=tailcall_fn,empty_fn";
     {
         rustc().input("lib.rs").crate_name("regular").crate_type("lib").opt_level("3").run();
 
         let regular_dump = llvm::llvm_objdump()
-            .arg("--disassemble-symbols=tailcall_fn,empty_fn,return_42")
+            .arg(disassemble_symbols_arg)
             .input("libregular.rlib")
-            .run();
+            .run()
+            .stdout_utf8();
 
-        llvm::llvm_filecheck().patterns("lib.rs").stdin_buf(regular_dump.stdout_utf8()).run();
+        llvm::llvm_filecheck().patterns("lib.rs").stdin_buf(regular_dump).run();
     }
 
     {
@@ -31,14 +33,15 @@ fn main() {
             .run();
 
         let hotpatch_dump = llvm::llvm_objdump()
-            .arg("--disassemble-symbols=tailcall_fn,empty_fn,return_42")
+            .arg(disassemble_symbols_arg)
             .input("libhotpatch.rlib")
-            .run();
+            .run()
+            .stdout_utf8();
 
         llvm::llvm_filecheck()
             .patterns("lib.rs")
             .check_prefix("HOTPATCH")
-            .stdin_buf(hotpatch_dump.stdout_utf8())
+            .stdin_buf(hotpatch_dump)
             .run();
     }
 }