Migrate x86_64-fortanix-unknown-sgx-lvi run-make test to rmake by Oneirical · Pull Request #129055 · rust-lang/rust (original) (raw)

There are other issues as well. Please apply:

diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs                                                                                                                                                                                              
index 84c292d019d..506b9424d39 100644                                                                                                                                                                                                                                                                                       
--- a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs                                                                                                                                                                                                                                                               
+++ b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs                                                                                                                                                                                                                                                               
@@ -41,13 +41,13 @@ fn main() {                                                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                                                                                            
     check("std::io::stdio::_print::[[:alnum:]]+", "print.with_frame_pointers.checks");                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                            
-    check("st_plus_one_global_asm", "rust_plus_one_global_asm.checks");                                                                                                                                                                                                                                                    
+    check("rust_plus_one_global_asm", "rust_plus_one_global_asm.checks");                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                            
-    check("_plus_one_c", "cc_plus_one_c.checks");                                                                                                                                                                                                                                                                          
-    check("_plus_one_c_asm", "cc_plus_one_c_asm.checks");                                                                                                                                                                                                                                                                  
-    check("_plus_one_cxx", "cc_plus_one_cxx.checks");                                                                                                                                                                                                                                                                      
-    check("_plus_one_cxx_asm", "cc_plus_one_cxx_asm.checks");                                                                                                                                                                                                                                                              
-    check("_plus_one_asm", "cc_plus_one_asm.checks");                                                                                                                                                                                                                                                                      
+    check("cc_plus_one_c", "cc_plus_one_c.checks");                                                                                                                                                                                                                                                                        
+    check("cc_plus_one_c_asm", "cc_plus_one_c_asm.checks");                                                                                                                                                                                                                                                                
+    check("cc_plus_one_cxx", "cc_plus_one_cxx.checks");                                                                                                                                                                                                                                                                    
+    check("cc_plus_one_cxx_asm", "cc_plus_one_cxx_asm.checks");                                                                                                                                                                                                                                                            
+    check("cc_plus_one_asm", "cc_plus_one_asm.checks");                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                            
     check("cmake_plus_one_c", "cmake_plus_one_c.checks");                                                                                                                                                                                                                                                                  
     check("cmake_plus_one_c_asm", "cmake_plus_one_c_asm.checks");                                                                                                                                                                                                                                                          
@@ -66,9 +66,11 @@ fn check(func_re: &str, mut checks: &str) {                                                                                                                                                                                                                                                              
         .stdout_utf8();                                                                                                                                                                                                                                                                                                    
     let re = regex::Regex::new(&format!("[[:blank:]]+{func_re}")).unwrap();                                                                                                                                                                                                                                                
     let func = re.find_iter(&dump).map(|m| m.as_str().trim()).collect::<Vec<&str>>().join(",");                                                                                                                                                                                                                            
+    assert!(!func.is_empty());                                                                                                                                                                                                                                                                                             
+                                                                                                                                                                                                                                                                                                                           
     let dump = llvm_objdump()                                                                                                                                                                                                                                                                                              
         .input("enclave/target/x86_64-fortanix-unknown-sgx/debug/enclave")                                                                                                                                                                                                                                                 
-        .arg(&format!("--disassemble-symbols={func}"))                                                                                                                                                                                                                                                                     
+        .args(&["--demangle", &format!("--disassemble-symbols={func}")])                                                                                                                                                                                                                                                   
         .run()                                                                                                                                                                                                                                                                                                             
         .stdout_utf8();                                                                                                                                                                                                                                                                                                    
     let dump = dump.as_bytes();