Undo changes to rustc CodegenBackend trait (rust-lang#706)

The goal is to eventually consume rustc as is (issue rust-lang#42).

In this change, we moved the json file generations out of the linker
to the codegen method. The RMC behavior is still the same.

Author: celinval

compiler/rustc_codegen_llvm/src/lib.rs

@@ -339,24 +339,27 @@ impl CodegenBackend for LlvmCodegenBackend {
         &self,
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
-    ) -> Result<(Box<dyn Any>, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
+    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
         let (codegen_results, work_products) = ongoing_codegen
             .downcast::<rustc_codegen_ssa::back::write::OngoingCodegen<LlvmCodegenBackend>>()
             .expect("Expected LlvmCodegenBackend's OngoingCodegen, found Box<Any>")
             .join(sess);
-        Ok((Box::new(codegen_results), work_products))
+
+        sess.time("llvm_dump_timing_file", || {
+            if sess.opts.debugging_opts.llvm_time_trace {
+                llvm_util::time_trace_profiler_finish("llvm_timings.json");
+            }
+        });
+
+        Ok((codegen_results, work_products))
     }
 
     fn link(
         &self,
         sess: &Session,
-        codegen_results: Box<dyn Any>,
+        codegen_results: CodegenResults,
         outputs: &OutputFilenames,
     ) -> Result<(), ErrorReported> {
-        let codegen_results = codegen_results
-            .downcast::<CodegenResults>()
-            .expect("Expected CodegenResults, found Box<Any>");
-
         use crate::back::archive::LlvmArchiveBuilder;
         use rustc_codegen_ssa::back::link::link_binary;
 

compiler/rustc_codegen_rmc/src/compiler_interface.rs

@@ -11,6 +11,7 @@ use cbmc::goto_program::SymbolTable;
 use cbmc::InternedString;
 use rmc_restrictions::VtableCtxResults;
 use rustc_codegen_ssa::traits::CodegenBackend;
+use rustc_codegen_ssa::{CodegenResults, CrateInfo};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorReported;
 use rustc_metadata::EncodedMetadata;
@@ -28,15 +29,6 @@ use std::iter::FromIterator;
 use std::path::PathBuf;
 use tracing::{debug, warn};
 
-// #[derive(RustcEncodable, RustcDecodable)]
-pub struct GotocCodegenResult {
-    pub crate_name: rustc_span::Symbol,
-    pub metadata: RmcMetadata,
-    pub symtab: SymbolTable,
-    pub type_map: BTreeMap<InternedString, InternedString>,
-    pub vtable_restrictions: Option<VtableCtxResults>,
-}
-
 #[derive(Clone)]
 pub struct GotocCodegenBackend();
 
@@ -58,14 +50,12 @@ impl CodegenBackend for GotocCodegenBackend {
     fn codegen_crate<'tcx>(
         &self,
         tcx: TyCtxt<'tcx>,
-        _metadata: EncodedMetadata,
-        _need_metadata_module: bool,
+        rustc_metadata: EncodedMetadata,
+        need_metadata_module: bool,
     ) -> Box<dyn Any> {
-        use rustc_hir::def_id::LOCAL_CRATE;
-
         super::utils::init();
 
-        check_options(&tcx.sess);
+        check_options(&tcx.sess, need_metadata_module);
 
         let codegen_units: &'tcx [CodegenUnit<'_>] = tcx.collect_and_partition_mono_items(()).1;
         let mut c = GotocCtx::new(tcx);
@@ -134,7 +124,7 @@ impl CodegenBackend for GotocCodegenBackend {
         );
 
         // Map MIR types to GotoC types
-        let type_map =
+        let type_map: BTreeMap<InternedString, InternedString> =
             BTreeMap::from_iter(c.type_map.into_iter().map(|(k, v)| (k, v.to_string().into())));
 
         // Get the vtable function pointer restrictions if requested
@@ -146,51 +136,53 @@ impl CodegenBackend for GotocCodegenBackend {
 
         let metadata = RmcMetadata { proof_harnesses: c.proof_harnesses };
 
-        Box::new(GotocCodegenResult {
-            crate_name: tcx.crate_name(LOCAL_CRATE) as rustc_span::Symbol,
-            metadata,
-            symtab,
-            type_map,
-            vtable_restrictions,
-        })
+        // No output should be generated if user selected no_codegen.
+        if !tcx.sess.opts.debugging_opts.no_codegen && tcx.sess.opts.output_types.should_codegen() {
+            let outputs = tcx.output_filenames(());
+            let base_filename = outputs.output_path(OutputType::Object);
+            write_file(&base_filename, "symtab.json", &symtab);
+            write_file(&base_filename, "type_map.json", &type_map);
+            write_file(&base_filename, "rmc-metadata.json", &metadata);
+            // If they exist, write out vtable virtual call function pointer restrictions
+            if let Some(restrictions) = vtable_restrictions {
+                write_file(&base_filename, "restrictions.json", &restrictions);
+            }
+        }
+
+        let work_products = FxHashMap::<WorkProductId, WorkProduct>::default();
+        Box::new((
+            CodegenResults {
+                modules: vec![],
+                allocator_module: None,
+                metadata_module: None,
+                metadata: rustc_metadata,
+                crate_info: CrateInfo::new(tcx, symtab.machine_model().architecture().to_string()),
+            },
+            work_products,
+        ))
     }
 
     fn join_codegen(
         &self,
         ongoing_codegen: Box<dyn Any>,
         _sess: &Session,
-    ) -> Result<(Box<dyn Any>, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
-        Ok((ongoing_codegen, FxHashMap::default()))
+    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
+        Ok(*ongoing_codegen
+            .downcast::<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>)>()
+            .unwrap())
     }
 
     fn link(
         &self,
-        sess: &Session,
-        codegen_results: Box<dyn Any>,
-        outputs: &OutputFilenames,
+        _sess: &Session,
+        _codegen_results: CodegenResults,
+        _outputs: &OutputFilenames,
     ) -> Result<(), ErrorReported> {
-        let result = codegen_results
-            .downcast::<GotocCodegenResult>()
-            .expect("in link: codegen_results is not a GotocCodegenResult");
-
-        // No output should be generated if user selected no_codegen.
-        if !sess.opts.debugging_opts.no_codegen && sess.opts.output_types.should_codegen() {
-            // "path.o"
-            let base_filename = outputs.path(OutputType::Object);
-            write_file(&base_filename, "symtab.json", &result.symtab);
-            write_file(&base_filename, "type_map.json", &result.type_map);
-            write_file(&base_filename, "rmc-metadata.json", &result.metadata);
-            // If they exist, write out vtable virtual call function pointer restrictions
-            if let Some(restrictions) = result.vtable_restrictions {
-                write_file(&base_filename, "restrictions.json", &restrictions);
-            }
-        }
-
         Ok(())
     }
 }
 
-fn check_options(session: &Session) {
+fn check_options(session: &Session, need_metadata_module: bool) {
     if !session.overflow_checks() {
         session.err("RMC requires overflow checks in order to provide a sound analysis.");
     }
@@ -202,6 +194,10 @@ fn check_options(session: &Session) {
         );
     }
 
+    if need_metadata_module {
+        session.err("RMC cannot generate metadata module.")
+    }
+
     session.abort_if_errors();
 }
 

compiler/rustc_codegen_ssa/src/traits/backend.rs

@@ -97,7 +97,7 @@ pub trait CodegenBackend {
         &self,
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
-    ) -> Result<(Box<dyn Any>, FxHashMap<WorkProductId, WorkProduct>), ErrorReported>;
+    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported>;
 
     /// This is called on the returned `Box<dyn Any>` from `join_codegen`
     ///
@@ -107,7 +107,7 @@ pub trait CodegenBackend {
     fn link(
         &self,
         sess: &Session,
-        codegen_results: Box<dyn Any>,
+        codegen_results: CodegenResults,
         outputs: &OutputFilenames,
     ) -> Result<(), ErrorReported>;
 }

compiler/rustc_driver/src/lib.rs

@@ -608,8 +608,7 @@ impl RustcDefaultCalls {
                     json::decode(&rlink_data).unwrap_or_else(|err| {
                         sess.fatal(&format!("failed to decode rlink: {}", err));
                     });
-                let result =
-                    compiler.codegen_backend().link(sess, Box::new(codegen_results), &outputs);
+                let result = compiler.codegen_backend().link(sess, codegen_results, &outputs);
                 abort_on_err(result, sess);
             } else {
                 sess.fatal("rlink must be a file")

compiler/rustc_interface/src/queries.rs

@@ -364,10 +364,6 @@ impl Linker {
         }
 
         if sess.opts.debugging_opts.no_link {
-            use rustc_codegen_ssa::CodegenResults;
-            let codegen_results = codegen_results
-                .downcast::<CodegenResults>()
-                .expect("Expected CodegenResults, found Box<Any>");
             // FIXME: use a binary format to encode the `.rlink` file
             let rlink_data = json::encode(&codegen_results).map_err(|err| {
                 sess.fatal(&format!("failed to encode rlink: {}", err));