experimental MIR-only RLIB support.

michaelwoerister · michaelwoerister · commit 96147469c572 · 2018-02-21T13:33:07.000+01:00
diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs
@@ -253,6 +253,11 @@ fn main() {
         if env::var_os("RUSTC_FORCE_UNSTABLE").is_some() {
             cmd.arg("-Z").arg("force-unstable-if-unmarked");
         }
+
+        // Don't use MIR only RLIBs for the compiler yet
+        if stage != "0" {
+            cmd.arg("-Zmir-only-rlibs=no");
+        }
     } else {
         // Override linker if necessary.
         if let Ok(host_linker) = env::var("RUSTC_HOST_LINKER") {
diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs
@@ -642,6 +642,7 @@ define_dep_nodes!( <'tcx>
 
     [] GetSymbolExportLevel(DefId),
 
+    [input] IsMirOnlyRlib(CrateNum),
 );
 
 trait DepNodeParams<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> : fmt::Debug {
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
@@ -1322,6 +1322,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
          epoch). Crates compiled with different epochs can be linked together."),
     run_dsymutil: Option<bool> = (None, parse_opt_bool, [TRACKED],
           "run `dsymutil` and delete intermediate object files"),
+
+    mir_only_rlibs: Option<bool> = (Some(true), parse_opt_bool, [TRACKED], "go!"),
 }
 
 pub fn default_lib_output() -> CrateType {
diff --git a/src/librustc/ty/maps/config.rs b/src/librustc/ty/maps/config.rs
@@ -50,6 +50,13 @@ impl<'tcx, M: QueryConfig<Key=DefId>> QueryDescription<'tcx> for M {
     }
 }
 
+
+impl<'tcx> QueryDescription<'tcx> for queries::is_mir_only_rlib<'tcx> {
+    fn describe(_tcx: TyCtxt, cnum: CrateNum) -> String {
+        format!("computing whether `{}` is a MIR-only RLIB", cnum)
+    }
+}
+
 impl<'tcx> QueryDescription<'tcx> for queries::is_copy_raw<'tcx> {
     fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {
         format!("computing whether `{}` is `Copy`", env.value)
diff --git a/src/librustc/ty/maps/mod.rs b/src/librustc/ty/maps/mod.rs
@@ -374,6 +374,8 @@ define_maps! { <'tcx>
     // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.
     [] fn instance_def_size_estimate: instance_def_size_estimate_dep_node(ty::InstanceDef<'tcx>)
         -> usize,
+
+    [] fn is_mir_only_rlib: IsMirOnlyRlib(CrateNum) -> bool,
 }
 
 //////////////////////////////////////////////////////////////////////
diff --git a/src/librustc/ty/maps/plumbing.rs b/src/librustc/ty/maps/plumbing.rs
@@ -936,6 +936,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
         DepKind::TargetFeaturesEnabled => { force!(target_features_enabled, def_id!()); }
 
         DepKind::GetSymbolExportLevel => { force!(symbol_export_level, def_id!()); }
+        DepKind::IsMirOnlyRlib => { force!(is_mir_only_rlib, krate!()); }
     }
 
     true
diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs
@@ -237,6 +237,8 @@ provide! { <'tcx> tcx, def_id, other, cdata,
 
     has_copy_closures => { cdata.has_copy_closures(tcx.sess) }
     has_clone_closures => { cdata.has_clone_closures(tcx.sess) }
+
+    is_mir_only_rlib => { cdata.root.is_mir_only_rlib }
 }
 
 pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
@@ -415,6 +415,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let has_default_lib_allocator =
             attr::contains_name(tcx.hir.krate_attrs(), "default_lib_allocator");
         let has_global_allocator = tcx.sess.has_global_allocator.get();
+
+        let is_mir_only_rlib = if tcx.sess.opts.debugging_opts.mir_only_rlibs != Some(false) {
+            let crate_types = tcx.sess.crate_types.borrow();
+            crate_types.len() == 1 && crate_types[0] == config::CrateTypeRlib
+        } else {
+            false
+        };
+
         let root = self.lazy(&CrateRoot {
             name: tcx.crate_name(LOCAL_CRATE),
             triple: tcx.sess.opts.target_triple.clone(),
@@ -423,6 +431,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             panic_strategy: tcx.sess.panic_strategy(),
             has_global_allocator: has_global_allocator,
             has_default_lib_allocator: has_default_lib_allocator,
+            is_mir_only_rlib,
             plugin_registrar_fn: tcx.sess
                 .plugin_registrar_fn
                 .get()
@@ -833,7 +842,8 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
             let needs_inline = types > 0 || attr::requests_inline(&ast_item.attrs);
             let is_const_fn = sig.constness == hir::Constness::Const;
             let ast = if is_const_fn { Some(body) } else { None };
-            let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
+            let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir ||
+                                    self.tcx.sess.opts.debugging_opts.mir_only_rlibs != Some(false);
             (ast, needs_inline || is_const_fn || always_encode_mir)
         } else {
             (None, false)
@@ -1115,14 +1125,16 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
                 _ => None,
             },
             mir: match item.node {
-                hir::ItemStatic(..) if self.tcx.sess.opts.debugging_opts.always_encode_mir => {
+                hir::ItemStatic(..) if self.tcx.sess.opts.debugging_opts.always_encode_mir ||
+                            self.tcx.sess.opts.debugging_opts.mir_only_rlibs != Some(false) => {
                     self.encode_optimized_mir(def_id)
                 }
                 hir::ItemConst(..) => self.encode_optimized_mir(def_id),
                 hir::ItemFn(_, _, constness, _, ref generics, _) => {
                     let has_tps = generics.ty_params().next().is_some();
                     let needs_inline = has_tps || attr::requests_inline(&item.attrs);
-                    let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir;
+                    let always_encode_mir = self.tcx.sess.opts.debugging_opts.always_encode_mir ||
+                                self.tcx.sess.opts.debugging_opts.mir_only_rlibs != Some(false);
                     if needs_inline || constness == hir::Constness::Const || always_encode_mir {
                         self.encode_optimized_mir(def_id)
                     } else {
diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs
@@ -191,6 +191,7 @@ pub struct CrateRoot {
     pub panic_strategy: PanicStrategy,
     pub has_global_allocator: bool,
     pub has_default_lib_allocator: bool,
+    pub is_mir_only_rlib: bool,
     pub plugin_registrar_fn: Option<DefIndex>,
     pub macro_derive_registrar: Option<DefIndex>,
 
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
@@ -192,6 +192,7 @@ use rustc::hir;
 use rustc::hir::itemlikevisit::ItemLikeVisitor;
 
 use rustc::hir::map as hir_map;
+use rustc::hir::def::Def;
 use rustc::hir::def_id::DefId;
 use rustc::middle::const_val::ConstVal;
 use rustc::middle::lang_items::{ExchangeMallocFnLangItem, StartFnLangItem};
@@ -301,6 +302,18 @@ pub fn collect_crate_mono_items<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                           mode: MonoItemCollectionMode)
                                           -> (FxHashSet<MonoItem<'tcx>>,
                                                      InliningMap<'tcx>) {
+    let current_crate_is_mir_only_rlib =
+        if tcx.sess.opts.debugging_opts.mir_only_rlibs != Some(false) {
+        let crate_types = tcx.sess.crate_types.borrow();
+        crate_types.len() == 1 && crate_types[0] == config::CrateTypeRlib
+    } else {
+        false
+    };
+
+    if current_crate_is_mir_only_rlib {
+        return (FxHashSet(), InliningMap::new())
+    }
+
     let roots = collect_roots(tcx, mode);
 
     debug!("Building mono item graph, beginning at roots");
@@ -342,6 +355,22 @@ fn collect_roots<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         };
 
         tcx.hir.krate().visit_all_item_likes(&mut visitor);
+
+        // Collect upstream roots
+        for &cnum in tcx.crates().iter() {
+            if tcx.is_mir_only_rlib(cnum) {
+                for &def_id in tcx.exported_symbol_ids(cnum).iter() {
+                    match tcx.describe_def(def_id) {
+                        Some(Def::Static(..)) => {
+                            visitor.output.push(MonoItem::Static(def_id));
+                        }
+                        _ => {
+                            visitor.push_if_root(def_id);
+                        }
+                    }
+                }
+            }
+        }
     }
 
     // We can only translate items that are instantiable - items all of
@@ -383,7 +412,8 @@ fn collect_items_rec<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         }
         MonoItem::Fn(instance) => {
             // Sanity check whether this ended up being collected accidentally
-            debug_assert!(should_monomorphize_locally(tcx, &instance));
+            debug_assert!(should_monomorphize_locally(tcx, &instance),
+                "Instantiation Error: {:?}", instance);
 
             // Keep track of the monomorphization recursion depth
             recursion_depth_reset = Some(check_recursion_limit(tcx,
@@ -736,8 +766,8 @@ fn should_monomorphize_locally<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, instance:
         }
         Some(_) => true,
         None => {
-            if tcx.is_exported_symbol(def_id) ||
-                tcx.is_foreign_item(def_id)
+            if tcx.is_foreign_item(def_id) ||
+              (!tcx.is_mir_only_rlib(def_id.krate) && tcx.is_exported_symbol(def_id))
             {
                 // We can link to the item in question, no instance needed
                 // in this crate
diff --git a/src/librustc_mir/monomorphize/mod.rs b/src/librustc_mir/monomorphize/mod.rs
@@ -42,30 +42,41 @@ pub fn assert_symbols_are_distinct<'a, 'tcx, I>(tcx: TyCtxt<'a, 'tcx, 'tcx>, tra
             let trans_item1 = pair[0].0;
             let trans_item2 = pair[1].0;
 
-            let span1 = trans_item1.local_span(tcx);
-            let span2 = trans_item2.local_span(tcx);
-
-            // Deterministically select one of the spans for error reporting
-            let span = match (span1, span2) {
-                (Some(span1), Some(span2)) => {
-                    Some(if span1.lo().0 > span2.lo().0 {
-                        span1
-                    } else {
-                        span2
-                    })
-                }
-                (Some(span), None) |
-                (None, Some(span)) => Some(span),
-                _ => None
-            };
-
-            let error_message = format!("symbol `{}` is already defined", sym1);
-
-            if let Some(span) = span {
-                tcx.sess.span_fatal(span, &error_message)
-            } else {
-                tcx.sess.fatal(&error_message)
-            }
+            bug!("encountered two distinct MonoItems with the same symbol name:\n\
+                  symbol name: {}\n\
+                  item 1: {:?}\n\
+                  item 2: {:?}",
+                  sym1,
+                  trans_item1,
+                  trans_item2)
+
+            // let span1 = trans_item1.local_span(tcx);
+            // let span2 = trans_item2.local_span(tcx);
+
+            // // Deterministically select one of the spans for error reporting
+            // let span = match (span1, span2) {
+            //     (Some(span1), Some(span2)) => {
+            //         Some(if span1.lo().0 > span2.lo().0 {
+            //             span1
+            //         } else {
+            //             span2
+            //         })
+            //     }
+            //     (Some(span), None) |
+            //     (None, Some(span)) => Some(span),
+            //     _ => None
+            // };
+
+
+            // let error_message = format!("assert_symbols_are_distinct: symbol `{}` is already defined", sym1);
+
+            // if let Some(span) = span {
+            //     tcx.sess.span_fatal(span, &error_message)
+            //     span_bug!(span, "{}", )
+
+            // } else {
+            //     tcx.sess.fatal(&error_message)
+            // }
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1322,6 +1322,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,`
`1322`	`1322`	`epoch). Crates compiled with different epochs can be linked together."),`
`1323`	`1323`	`run_dsymutil: Option<bool> = (None, parse_opt_bool, [TRACKED],`
`1324`	`1324`	"run `dsymutil` and delete intermediate object files"),
	`1325`	`+`
	`1326`	`+ mir_only_rlibs: Option<bool> = (Some(true), parse_opt_bool, [TRACKED], "go!"),`
`1325`	`1327`	`}`
`1326`	`1328`
`1327`	`1329`	`pub fn default_lib_output() -> CrateType {`
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,13 @@ impl<'tcx, M: QueryConfig<Key=DefId>> QueryDescription<'tcx> for M {`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
	`53`	`+`
	`54`	`+impl<'tcx> QueryDescription<'tcx> for queries::is_mir_only_rlib<'tcx> {`
	`55`	`+ fn describe(_tcx: TyCtxt, cnum: CrateNum) -> String {`
	`56`	+ format!("computing whether `{}` is a MIR-only RLIB", cnum)
	`57`	`+ }`
	`58`	`+}`
	`59`	`+`
`53`	`60`	`impl<'tcx> QueryDescription<'tcx> for queries::is_copy_raw<'tcx> {`
`54`	`61`	`fn describe(_tcx: TyCtxt, env: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> String {`
`55`	`62`	format!("computing whether `{}` is `Copy`", env.value)
Original file line number	Diff line number	Diff line change
`@@ -374,6 +374,8 @@ define_maps! { <'tcx>`
`374`	`374`	`// Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.`
`375`	`375`	`[] fn instance_def_size_estimate: instance_def_size_estimate_dep_node(ty::InstanceDef<'tcx>)`
`376`	`376`	`-> usize,`
	`377`	`+`
	`378`	`+ [] fn is_mir_only_rlib: IsMirOnlyRlib(CrateNum) -> bool,`
`377`	`379`	`}`
`378`	`380`
`379`	`381`	`//////////////////////////////////////////////////////////////////////`
Original file line number	Diff line number	Diff line change
`@@ -936,6 +936,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,`
`936`	`936`	`DepKind::TargetFeaturesEnabled => { force!(target_features_enabled, def_id!()); }`
`937`	`937`
`938`	`938`	`DepKind::GetSymbolExportLevel => { force!(symbol_export_level, def_id!()); }`
	`939`	`+ DepKind::IsMirOnlyRlib => { force!(is_mir_only_rlib, krate!()); }`
`939`	`940`	`}`
`940`	`941`
`941`	`942`	`true`
Original file line number	Diff line number	Diff line change
`@@ -237,6 +237,8 @@ provide! { <'tcx> tcx, def_id, other, cdata,`
`237`	`237`
`238`	`238`	`has_copy_closures => { cdata.has_copy_closures(tcx.sess) }`
`239`	`239`	`has_clone_closures => { cdata.has_clone_closures(tcx.sess) }`
	`240`	`+`
	`241`	`+ is_mir_only_rlib => { cdata.root.is_mir_only_rlib }`
`240`	`242`	`}`
`241`	`243`
`242`	`244`	`pub fn provide<'tcx>(providers: &mut Providers<'tcx>) {`