Modify trans to skip generating .o files

This checks the `previous_work_products` data from the dep-graph and
tries to simply copy a `.o` file if possible.  We also add new
work-products into the dep-graph, and create edges to/from the dep-node
for a work-product.

Author: nikomatsakis

src/librustc_incremental/lib.rs

@@ -41,4 +41,6 @@ pub use assert_dep_graph::assert_dep_graph;
 pub use calculate_svh::SvhCalculate;
 pub use persist::load_dep_graph;
 pub use persist::save_dep_graph;
+pub use persist::save_trans_partition;
 pub use persist::save_work_products;
+pub use persist::in_incr_comp_dir;

src/librustc_incremental/persist/mod.rs

@@ -19,7 +19,10 @@ mod hash;
 mod load;
 mod save;
 mod util;
+mod work_product;
 
 pub use self::load::load_dep_graph;
 pub use self::save::save_dep_graph;
 pub use self::save::save_work_products;
+pub use self::work_product::save_trans_partition;
+pub use self::util::in_incr_comp_dir;

src/librustc_incremental/persist/work_product.rs

@@ -0,0 +1,61 @@
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! This module contains files for saving intermediate work-products.
+
+use persist::util::*;
+use rustc::dep_graph::{WorkProduct, WorkProductId};
+use rustc::session::Session;
+use std::fs;
+use std::path::Path;
+use std::sync::Arc;
+
+pub fn save_trans_partition(sess: &Session,
+                            partition_name: &str,
+                            partition_hash: u64,
+                            path_to_obj_file: &Path) {
+    debug!("save_trans_partition({:?},{},{})",
+           partition_name,
+           partition_hash,
+           path_to_obj_file.display());
+    if sess.opts.incremental.is_none() {
+        return;
+    }
+    let id = Arc::new(WorkProductId::PartitionObjectFile(partition_name.to_string()));
+    let file_name = format!("cgu-{}", partition_name);
+    let path_in_incr_dir = in_incr_comp_dir(sess, &file_name).unwrap();
+
+    // try to delete the file if it already exists
+    //
+    // FIXME(#34955) we can be smarter here -- if we are re-using, no need to do anything
+    if path_in_incr_dir.exists() {
+        let _ = fs::remove_file(&path_in_incr_dir);
+    }
+
+    match
+        fs::hard_link(path_to_obj_file, &path_in_incr_dir)
+        .or_else(|_| fs::copy(path_to_obj_file, &path_in_incr_dir).map(|_| ()))
+    {
+        Ok(_) => {
+            let work_product = WorkProduct {
+                input_hash: partition_hash,
+                file_name: file_name,
+            };
+            sess.dep_graph.insert_work_product(&id, work_product);
+        }
+        Err(err) => {
+            sess.warn(&format!("error copying object file `{}` \
+                                to incremental directory as `{}`: {}",
+                               path_to_obj_file.display(),
+                               path_in_incr_dir.display(),
+                               err));
+        }
+    }
+}

src/librustc_trans/back/write.rs

@@ -10,13 +10,14 @@
 
 use back::lto;
 use back::link::{get_linker, remove};
+use rustc_incremental::save_trans_partition;
 use session::config::{OutputFilenames, Passes, SomePasses, AllPasses};
 use session::Session;
 use session::config::{self, OutputType};
 use llvm;
 use llvm::{ModuleRef, TargetMachineRef, PassManagerRef, DiagnosticInfoRef, ContextRef};
 use llvm::SMDiagnosticRef;
-use {CrateTranslation, ModuleTranslation};
+use {CrateTranslation, ModuleLlvm, ModuleSource, ModuleTranslation};
 use util::common::time;
 use util::common::path2cstr;
 use errors::{self, Handler, Level, DiagnosticBuilder};
@@ -26,6 +27,7 @@ use syntax_pos::MultiSpan;
 use std::collections::HashMap;
 use std::ffi::{CStr, CString};
 use std::fs;
+use std::io;
 use std::path::{Path, PathBuf};
 use std::str;
 use std::sync::{Arc, Mutex};
@@ -422,10 +424,11 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo
 // Unsafe due to LLVM calls.
 unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
                                mtrans: ModuleTranslation,
+                               mllvm: ModuleLlvm,
                                config: ModuleConfig,
                                output_names: OutputFilenames) {
-    let llmod = mtrans.llmod;
-    let llcx = mtrans.llcx;
+    let llmod = mllvm.llmod;
+    let llcx = mllvm.llcx;
     let tm = config.tm;
 
     // llcx doesn't outlive this function, so we can put this on the stack.
@@ -628,8 +631,14 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
 pub fn cleanup_llvm(trans: &CrateTranslation) {
     for module in trans.modules.iter() {
         unsafe {
-            llvm::LLVMDisposeModule(module.llmod);
-            llvm::LLVMContextDispose(module.llcx);
+            match module.source {
+                ModuleSource::Translated(llvm) => {
+                    llvm::LLVMDisposeModule(llvm.llmod);
+                    llvm::LLVMContextDispose(llvm.llcx);
+                }
+                ModuleSource::Preexisting(_) => {
+                }
+            }
         }
     }
 }
@@ -743,6 +752,13 @@ pub fn run_passes(sess: &Session,
         run_work_multithreaded(sess, work_items, num_workers);
     }
 
+    // If in incr. comp. mode, preserve the `.o` files for potential re-use
+    for mtrans in trans.modules.iter() {
+        let path_to_obj = crate_output.temp_path(OutputType::Object, Some(&mtrans.name));
+        debug!("wrote module {:?} to {:?}", mtrans.name, path_to_obj);
+        save_trans_partition(sess, &mtrans.name, mtrans.symbol_name_hash, &path_to_obj);
+    }
+
     // All codegen is finished.
     unsafe {
         llvm::LLVMRustDisposeTargetMachine(tm);
@@ -913,13 +929,46 @@ fn build_work_item(sess: &Session,
     }
 }
 
+fn link_or_copy<P: AsRef<Path>, Q: AsRef<Path>>(p: P, q: Q) -> io::Result<()> {
+    let p = p.as_ref();
+    let q = q.as_ref();
+    if q.exists() {
+        try!(fs::remove_file(&q));
+    }
+    fs::hard_link(p, q)
+        .or_else(|_| fs::copy(p, q).map(|_| ()))
+}
+
 fn execute_work_item(cgcx: &CodegenContext,
                      work_item: WorkItem) {
     unsafe {
-        optimize_and_codegen(cgcx,
-                             work_item.mtrans,
-                             work_item.config,
-                             work_item.output_names);
+        match work_item.mtrans.source {
+            ModuleSource::Translated(mllvm) => {
+                debug!("llvm-optimizing {:?}", work_item.mtrans.name);
+                optimize_and_codegen(cgcx,
+                                     work_item.mtrans,
+                                     mllvm,
+                                     work_item.config,
+                                     work_item.output_names);
+            }
+            ModuleSource::Preexisting(ref buf) => {
+                let obj_out = work_item.output_names.temp_path(OutputType::Object,
+                                                               Some(&work_item.mtrans.name));
+                debug!("copying pre-existing module `{}` from {} to {}",
+                       work_item.mtrans.name,
+                       buf.display(),
+                       obj_out.display());
+                match link_or_copy(buf, &obj_out) {
+                    Ok(()) => { }
+                    Err(err) => {
+                        cgcx.handler.err(&format!("unable to copy {} to {}: {}",
+                                                  buf.display(),
+                                                  obj_out.display(),
+                                                  err));
+                    }
+                }
+            }
+        }
     }
 }