Unlink temporary file hard links from previous session before writing into them

Author: compiler-errors

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -410,6 +410,14 @@ fn emit_module(
     }
 
     let tmp_file = output_filenames.temp_path(OutputType::Object, Some(&name));
+
+    // Ensure we don't overwrite any hard links from previous compilation sessions.
+    if let Err(e) = fs::remove_file(tmp_file) {
+        if e.kind() != io::ErrorKind::NotFound {
+            return Err(format!("failed to remove {}: {}", tmp_file.display(), e));
+        }
+    }
+
     let file = match File::create(&tmp_file) {
         Ok(file) => file,
         Err(err) => return Err(format!("error creating object file: {}", err)),

compiler/rustc_codegen_gcc/src/back/write.rs

@@ -38,6 +38,10 @@ pub(crate) unsafe fn codegen(
         let bc_out = cgcx.output_filenames.temp_path(OutputType::Bitcode, module_name);
         let obj_out = cgcx.output_filenames.temp_path(OutputType::Object, module_name);
 
+        // Ensure we don't overwrite any hard links from previous compilation sessions.
+        ensure_removed(dcx, &bc_out);
+        ensure_removed(dcx, &obj_out);
+
         if config.bitcode_needed() {
             if fat_lto {
                 let _timer = cgcx
@@ -117,15 +121,19 @@ pub(crate) unsafe fn codegen(
         }
 
         if config.emit_ir {
-            let out = cgcx.output_filenames.temp_path(OutputType::LlvmAssembly, module_name);
-            std::fs::write(out, "").expect("write file");
+            let ir_out = cgcx.output_filenames.temp_path(OutputType::LlvmAssembly, module_name);
+            // Ensure we don't overwrite any hard links from previous compilation sessions.
+            ensure_removed(dcx, &ir_out);
+            std::fs::write(ir_out, "").expect("write file");
         }
 
         if config.emit_asm {
             let _timer =
                 cgcx.prof.generic_activity_with_arg("GCC_module_codegen_emit_asm", &*module.name);
-            let path = cgcx.output_filenames.temp_path(OutputType::Assembly, module_name);
-            context.compile_to_file(OutputKind::Assembler, path.to_str().expect("path to str"));
+            let asm_out = cgcx.output_filenames.temp_path(OutputType::Assembly, module_name);
+            // Ensure we don't overwrite any hard links from previous compilation sessions.
+            ensure_removed(dcx, &asm_out);
+            context.compile_to_file(OutputKind::Assembler, asm_out.to_str().expect("path to str"));
         }
 
         match config.emit_obj {

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -820,6 +820,10 @@ pub(crate) unsafe fn codegen(
         let bc_out = cgcx.output_filenames.temp_path(OutputType::Bitcode, module_name);
         let obj_out = cgcx.output_filenames.temp_path(OutputType::Object, module_name);
 
+        // Ensure we don't overwrite any hard links from previous compilation sessions.
+        ensure_removed(dcx, &bc_out);
+        ensure_removed(dcx, &obj_out);
+
         if config.bitcode_needed() {
             if config.emit_bc || config.emit_obj == EmitObj::Bitcode {
                 let thin = {
@@ -860,8 +864,11 @@ pub(crate) unsafe fn codegen(
         if config.emit_ir {
             let _timer =
                 cgcx.prof.generic_activity_with_arg("LLVM_module_codegen_emit_ir", &*module.name);
-            let out = cgcx.output_filenames.temp_path(OutputType::LlvmAssembly, module_name);
-            let out_c = path_to_c_string(&out);
+            let ir_out = cgcx.output_filenames.temp_path(OutputType::LlvmAssembly, module_name);
+            // Ensure we don't overwrite any hard links from previous compilation sessions.
+            ensure_removed(dcx, &ir_out);
+
+            let out_c = path_to_c_string(&ir_out);
 
             extern "C" fn demangle_callback(
                 input_ptr: *const c_char,
@@ -893,16 +900,20 @@ pub(crate) unsafe fn codegen(
                 unsafe { llvm::LLVMRustPrintModule(llmod, out_c.as_ptr(), demangle_callback) };
 
             if result == llvm::LLVMRustResult::Success {
-                record_artifact_size(&cgcx.prof, "llvm_ir", &out);
+                record_artifact_size(&cgcx.prof, "llvm_ir", &ir_out);
             }
 
-            result.into_result().map_err(|()| llvm_err(dcx, LlvmError::WriteIr { path: &out }))?;
+            result
+                .into_result()
+                .map_err(|()| llvm_err(dcx, LlvmError::WriteIr { path: &ir_out }))?;
         }
 
         if config.emit_asm {
             let _timer =
                 cgcx.prof.generic_activity_with_arg("LLVM_module_codegen_emit_asm", &*module.name);
-            let path = cgcx.output_filenames.temp_path(OutputType::Assembly, module_name);
+            let asm_out = cgcx.output_filenames.temp_path(OutputType::Assembly, module_name);
+            // Ensure we don't overwrite any hard links from previous compilation sessions.
+            ensure_removed(dcx, &asm_out);
 
             // We can't use the same module for asm and object code output,
             // because that triggers various errors like invalid IR or broken
@@ -918,7 +929,7 @@ pub(crate) unsafe fn codegen(
                 tm.raw(),
                 config.no_builtins,
                 llmod,
-                &path,
+                &asm_out,
                 None,
                 llvm::FileType::AssemblyFile,
                 &cgcx.prof,
@@ -933,6 +944,9 @@ pub(crate) unsafe fn codegen(
                     .generic_activity_with_arg("LLVM_module_codegen_emit_obj", &*module.name);
 
                 let dwo_out = cgcx.output_filenames.temp_path_dwo(module_name);
+                // Ensure we don't overwrite any hard links from previous compilation sessions.
+                ensure_removed(dcx, &dwo_out);
+
                 let dwo_out = match (cgcx.split_debuginfo, cgcx.split_dwarf_kind) {
                     // Don't change how DWARF is emitted when disabled.
                     (SplitDebuginfo::Off, _) => None,

compiler/rustc_codegen_ssa/src/base.rs

@@ -640,20 +640,20 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         let metadata_cgu_name =
             cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("metadata")).to_string();
         tcx.sess.time("write_compressed_metadata", || {
-            let file_name =
+            let metadata_out =
                 tcx.output_filenames(()).temp_path(OutputType::Metadata, Some(&metadata_cgu_name));
             let data = create_compressed_metadata_file(
                 tcx.sess,
                 &metadata,
                 &exported_symbols::metadata_symbol_name(tcx),
             );
-            if let Err(error) = std::fs::write(&file_name, data) {
+            if let Err(error) = std::fs::write(&metadata_out, data) {
                 tcx.dcx().emit_fatal(errors::MetadataObjectFileWrite { error });
             }
             CompiledModule {
                 name: metadata_cgu_name,
                 kind: ModuleKind::Metadata,
-                object: Some(file_name),
+                object: Some(metadata_out),
                 dwarf_object: None,
                 bytecode: None,
                 assembly: None,

tests/run-make/dirty-incr-due-to-hard-link/rmake.rs

@@ -0,0 +1,25 @@
+//@ only-x86_64-unknown-linux-gnu
+
+use run_make_support::{run, rustc};
+
+fn main() {
+    let mk_rustc = || {
+        let mut rustc = rustc();
+        rustc.input("test.rs").incremental("incr").arg("-Csave-temps").output("test");
+        rustc
+    };
+
+    // Revision 1
+    mk_rustc().cfg("rpass1").run();
+
+    run("test");
+
+    // Revision 2
+    mk_rustc().cfg("cfail2").run_fail();
+    // Expected to fail.
+
+    // Revision 3
+    mk_rustc().cfg("rpass3").run();
+
+    run("test");
+}

tests/run-make/dirty-incr-due-to-hard-link/test.rs

@@ -0,0 +1,31 @@
+#[inline(never)]
+#[cfg(any(rpass1, rpass3))]
+fn a() -> i32 {
+    0
+}
+
+#[cfg(any(cfail2))]
+fn a() -> i32 {
+    1
+}
+
+fn main() {
+    evil::evil();
+    assert_eq!(a(), 0);
+}
+
+mod evil {
+    #[cfg(any(rpass1, rpass3))]
+    pub fn evil() {
+        unsafe {
+            std::arch::asm!("/*  */");
+        }
+    }
+
+    #[cfg(any(cfail2))]
+    pub fn evil() {
+        unsafe {
+            std::arch::asm!("missing");
+        }
+    }
+}