This is the current result of a git diff on the compiler folder that ignores rustc_codegen_rmc and cbmc folders.

diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 64fedb7bc1a..02d46414fd9 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -323,27 +323,24 @@ fn join_codegen(
         &self,
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
-    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
+    ) -> Result<(Box<dyn Any>, 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);
-
-        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))
+        Ok((Box::new(codegen_results), work_products))
     }
 
     fn link(
         &self,
         sess: &Session,
-        codegen_results: CodegenResults,
+        codegen_results: Box<dyn Any>,
         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;
 
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
index 9c8bc3b2109..e9323b98f82 100644
--- a/compiler/rustc_codegen_ssa/src/traits/backend.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -97,7 +97,7 @@ fn join_codegen(
         &self,
         ongoing_codegen: Box<dyn Any>,
         sess: &Session,
-    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported>;
+    ) -> Result<(Box<dyn Any>, FxHashMap<WorkProductId, WorkProduct>), ErrorReported>;
 
     /// This is called on the returned `Box<dyn Any>` from `join_codegen`
     ///
@@ -107,7 +107,7 @@ fn join_codegen(
     fn link(
         &self,
         sess: &Session,
-        codegen_results: CodegenResults,
+        codegen_results: Box<dyn Any>,
         outputs: &OutputFilenames,
     ) -> Result<(), ErrorReported>;
 }
diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs
index 09fe3a552a0..787cc9a6543 100644
--- a/compiler/rustc_driver/src/lib.rs
+++ b/compiler/rustc_driver/src/lib.rs
@@ -595,6 +595,24 @@ fn show_content_with_pager(content: &str) {
 }
 
 impl RustcDefaultCalls {
+    fn process_rlink(sess: &Session, compiler: &interface::Compiler) -> Result<(), ErrorReported> {
+        if let Input::File(file) = compiler.input() {
+            // FIXME: #![crate_type] and #![crate_name] support not implemented yet
+            let attrs = vec![];
+            sess.init_crate_types(collect_crate_types(sess, &attrs));
+            let outputs = compiler.build_output_filenames(&sess, &attrs);
+            let rlink_data = fs::read_to_string(file).unwrap_or_else(|err| {
+                sess.fatal(&format!("failed to read rlink file: {}", err));
+            });
+            let codegen_results: CodegenResults = json::decode(&rlink_data).unwrap_or_else(|err| {
+                sess.fatal(&format!("failed to decode rlink: {}", err));
+            });
+            compiler.codegen_backend().link(&sess, Box::new(codegen_results), &outputs)
+        } else {
+            sess.fatal("rlink must be a file")
+        }
+    }
+
     pub fn try_process_rlink(sess: &Session, compiler: &interface::Compiler) -> Compilation {
         if sess.opts.debugging_opts.link_only {
             if let Input::File(file) = compiler.input() {
@@ -608,7 +626,8 @@ pub fn try_process_rlink(sess: &Session, compiler: &interface::Compiler) -> Comp
                     json::decode(&rlink_data).unwrap_or_else(|err| {
                         sess.fatal(&format!("failed to decode rlink: {}", err));
                     });
-                let result = compiler.codegen_backend().link(sess, codegen_results, &outputs);
+                let result =
+                    compiler.codegen_backend().link(sess, Box::new(codegen_results), &outputs);
                 abort_on_err(result, sess);
             } else {
                 sess.fatal("rlink must be a file")
diff --git a/compiler/rustc_interface/Cargo.toml b/compiler/rustc_interface/Cargo.toml
index 07af2201f5f..14a2eafb55b 100644
--- a/compiler/rustc_interface/Cargo.toml
+++ b/compiler/rustc_interface/Cargo.toml
@@ -30,6 +30,7 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_codegen_ssa = { path = "../rustc_codegen_ssa" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_codegen_llvm = { path = "../rustc_codegen_llvm", optional = true }
+rustc_codegen_rmc = { path = "../rustc_codegen_rmc" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_metadata = { path = "../rustc_metadata" }
 rustc_const_eval = { path = "../rustc_const_eval" }
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index f188ad35605..a2828f5c2b2 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -364,6 +364,10 @@ pub fn link(self) -> Result<()> {
         }
 
         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));
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 6b666d7c292..7d17012535d 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -772,6 +772,7 @@ macro_rules! tracked {
     tracked!(show_span, Some(String::from("abc")));
     tracked!(src_hash_algorithm, Some(SourceFileHashAlgorithm::Sha1));
     tracked!(symbol_mangling_version, Some(SymbolManglingVersion::V0));
+    tracked!(symbol_table_passes, vec![String::from("identity")]);
     tracked!(teach, true);
     tracked!(thinlto, Some(true));
     tracked!(thir_unsafeck, true);
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 04e183a9ba5..f17f6bda73a 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -255,6 +255,7 @@ pub fn get_codegen_backend(
             filename if filename.contains('.') => load_backend_from_dylib(filename.as_ref()),
             #[cfg(feature = "llvm")]
             "llvm" => rustc_codegen_llvm::LlvmCodegenBackend::new,
+            "gotoc" => rustc_codegen_rmc::GotocCodegenBackend::new,
             backend_name => get_codegen_sysroot(maybe_sysroot, backend_name),
         }
     });
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index e78b6fd092d..6a537dbe05d 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -21,7 +21,7 @@
 pub struct SwitchTargets {
     /// Possible values. The locations to branch to in each case
     /// are found in the corresponding indices from the `targets` vector.
-    values: SmallVec<[u128; 1]>,
+    pub values: SmallVec<[u128; 1]>,
 
     /// Possible branch sites. The last element of this vector is used
     /// for the otherwise branch, so targets.len() == values.len() + 1
@@ -35,7 +35,7 @@ pub struct SwitchTargets {
     //
     // However we’ve decided to keep this as-is until we figure a case
     // where some other approach seems to be strictly better than other.
-    targets: SmallVec<[BasicBlock; 2]>,
+    pub targets: SmallVec<[BasicBlock; 2]>,
 }
 
 impl SwitchTargets {
diff --git a/compiler/rustc_middle/src/ty/consts/int.rs b/compiler/rustc_middle/src/ty/consts/int.rs
index 8262bc26199..16cc0bed920 100644
--- a/compiler/rustc_middle/src/ty/consts/int.rs
+++ b/compiler/rustc_middle/src/ty/consts/int.rs
@@ -122,8 +122,8 @@ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 pub struct ScalarInt {
     /// The first `size` bytes of `data` are the value.
     /// Do not try to read less or more bytes than that. The remaining bytes must be 0.
-    data: u128,
-    size: u8,
+    pub data: u128,
+    pub size: u8,
 }
 
 // Cannot derive these, as the derives take references to the fields, and we
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 673733faa76..8ce36956471 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -365,10 +365,10 @@ pub struct CReaderCacheKey {
 pub struct TyS<'tcx> {
     /// This field shouldn't be used directly and may be removed in the future.
     /// Use `TyS::kind()` instead.
-    kind: TyKind<'tcx>,
+    pub kind: TyKind<'tcx>,
     /// This field shouldn't be used directly and may be removed in the future.
     /// Use `TyS::flags()` instead.
-    flags: TypeFlags,
+    pub flags: TypeFlags,
 
     /// This is a kind of confusing thing: it stores the smallest
     /// binder such that
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 3f279a045f1..b7a088358cc 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -1333,6 +1333,9 @@ mod parse {
     symbol_mangling_version: Option<SymbolManglingVersion> = (None,
         parse_symbol_mangling_version, [TRACKED],
         "which mangling version to use for symbol names ('legacy' (default) or 'v0')"),
+    symbol_table_passes: Vec<String> = (Vec::new(), parse_list, [TRACKED],
+        "transformations to perform to the symbol table after it has been generated. \
+        space separated"),
     teach: bool = (false, parse_bool, [TRACKED],
         "show extended diagnostic help (default: no)"),
     temps_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],

It looks like changes can be broken down into the following categories:

Enable symbol_table_passes options.
Make some APIs public.
Include rmc codegen as a backend option.

Compiler interface: remove need to patch upstream API #42

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions