DEPS_rustc_resolve := rustc rustc_front log syntax
DEPS_rustc_platform_intrinsics := rustc rustc_llvm
DEPS_rustc_privacy := rustc rustc_front log syntax
-DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
+DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \
log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics
DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics
use rustc::front;
use rustc::front::map as hir_map;
use rustc_mir as mir;
+use rustc_mir::mir_map::MirMap;
use rustc::session::Session;
use rustc::session::config::{self, Input, OutputFilenames, OutputType};
use rustc::session::search_paths::PathKind;
use rustc::middle;
use rustc::plugin::registry::Registry;
use rustc::plugin;
+use rustc::util::nodemap::NodeMap;
use rustc::util::common::time;
use rustc_borrowck as borrowck;
use rustc_resolve as resolve;
&arenas,
&id,
control.make_glob_map,
- |tcx, analysis| {
+ |tcx, mir_map, analysis| {
{
let state = CompileState::state_after_analysis(input,
println!("Pre-trans");
tcx.print_debug_stats();
}
- let trans = phase_4_translate_to_llvm(tcx, analysis);
+ let trans = phase_4_translate_to_llvm(tcx, &mir_map, analysis);
if log_enabled!(::log::INFO) {
println!("Post-trans");
f: F)
-> R
where F: for<'a> FnOnce(&'a ty::ctxt<'tcx>,
+ MirMap<'tcx>,
ty::CrateAnalysis) -> R
{
let time_passes = sess.time_passes();
time(time_passes, "match checking", ||
middle::check_match::check_crate(tcx));
- match tcx.sess.opts.unstable_features {
+ let mir_map = match tcx.sess.opts.unstable_features {
UnstableFeatures::Disallow => {
// use this as a shorthand for beta/stable, and skip
// MIR construction there until known regressions are
// addressed
+ NodeMap()
}
UnstableFeatures::Allow | UnstableFeatures::Cheat => {
- let _mir_map =
- time(time_passes, "MIR dump", ||
- mir::mir_map::build_mir_for_crate(tcx));
+ time(time_passes, "MIR dump", ||
+ mir::mir_map::build_mir_for_crate(tcx))
}
- }
+ };
time(time_passes, "liveness checking", ||
middle::liveness::check_crate(tcx));
// The above three passes generate errors w/o aborting
tcx.sess.abort_if_errors();
- f(tcx, ty::CrateAnalysis {
+ f(tcx, mir_map, ty::CrateAnalysis {
export_map: export_map,
exported_items: exported_items,
public_items: public_items,
/// Run the translation phase to LLVM, after which the AST and analysis can
/// be discarded.
-pub fn phase_4_translate_to_llvm(tcx: &ty::ctxt, analysis: ty::CrateAnalysis)
- -> trans::CrateTranslation {
+pub fn phase_4_translate_to_llvm<'tcx>(tcx: &ty::ctxt<'tcx>,
+ mir_map: &MirMap<'tcx>,
+ analysis: ty::CrateAnalysis)
+ -> trans::CrateTranslation {
let time_passes = tcx.sess.time_passes();
time(time_passes, "resolving dependency formats", ||
// Option dance to work around the lack of stack once closures.
time(time_passes, "translation", move ||
- trans::trans_crate(tcx, analysis))
+ trans::trans_crate(tcx, mir_map, analysis))
}
/// Run LLVM itself, producing a bitcode file, assembly file or object file
arenas,
id,
resolve::MakeGlobMap::No,
- |tcx, _| {
+ |tcx, _, _| {
let annotation = TypedAnnotation { tcx: tcx };
f(&annotation, payload, &ast_map.forest.krate)
})
&arenas,
&id,
resolve::MakeGlobMap::No,
- |tcx, _| {
+ |tcx, _, _| {
print_flowgraph(variants, tcx, code, mode, out)
})
}
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
+#![feature(slice_patterns)]
#![feature(staged_api)]
#![feature(unicode)]
#![feature(vec_push_all)]
extern crate rustc_back;
extern crate rustc_front;
extern crate rustc_llvm as llvm;
+extern crate rustc_mir;
extern crate rustc_platform_intrinsics as intrinsics;
extern crate serialize;
use middle::subst::Substs;
use middle::ty::{self, Ty, HasTypeFlags};
use rustc::front::map as hir_map;
+use rustc_mir::mir_map::MirMap;
use session::config::{self, NoDebugInfo, FullDebugInfo};
use session::Session;
use trans::_match;
}).collect()
}
-pub fn trans_crate(tcx: &ty::ctxt, analysis: ty::CrateAnalysis) -> CrateTranslation {
+pub fn trans_crate<'tcx>(tcx: &ty::ctxt<'tcx>,
+ mir_map: &MirMap<'tcx>,
+ analysis: ty::CrateAnalysis)
+ -> CrateTranslation {
let ty::CrateAnalysis { export_map, reachable, name, .. } = analysis;
let krate = tcx.map.krate();
let shared_ccx = SharedCrateContext::new(&link_meta.crate_name,
codegen_units,
tcx,
+ &mir_map,
export_map,
Sha256::new(),
link_meta.clone(),
use middle::def::ExportMap;
use middle::def_id::DefId;
use middle::traits;
+use rustc_mir::mir_map::MirMap;
use trans::adt;
use trans::base;
use trans::builder::Builder;
stats: Stats,
check_overflow: bool,
check_drop_flag_for_sanity: bool,
+ mir_map: &'a MirMap<'tcx>,
available_drop_glues: RefCell<FnvHashMap<DropGlueKind<'tcx>, String>>,
use_dll_storage_attrs: bool,
pub fn new(crate_name: &str,
local_count: usize,
tcx: &'b ty::ctxt<'tcx>,
+ mir_map: &'b MirMap<'tcx>,
export_map: ExportMap,
symbol_hasher: Sha256,
link_meta: LinkMeta,
link_meta: link_meta,
symbol_hasher: RefCell::new(symbol_hasher),
tcx: tcx,
+ mir_map: mir_map,
stats: Stats {
n_glues_created: Cell::new(0),
n_null_glues: Cell::new(0),
pub fn use_dll_storage_attrs(&self) -> bool {
self.shared.use_dll_storage_attrs()
}
+
+ pub fn mir_map(&self) -> &'b MirMap<'tcx> {
+ self.shared.mir_map
+ }
}
pub struct TypeOfDepthLock<'a, 'tcx: 'a>(&'a LocalCrateContext<'tcx>);
&arenas,
&name,
resolve::MakeGlobMap::No,
- |tcx, analysis| {
+ |tcx, _, analysis| {
let ty::CrateAnalysis { exported_items, public_items, .. } = analysis;
// Convert from a NodeId set to a DefId set since we don't always have easy access
let ast_map = driver::make_map(&sess, &mut hir_forest);
driver::phase_3_run_analysis_passes(
- &sess, ast_map, &arenas, &id, MakeGlobMap::No, |tcx, analysis| {
+ &sess, ast_map, &arenas, &id, MakeGlobMap::No, |tcx, mir_map, analysis| {
- let trans = driver::phase_4_translate_to_llvm(tcx, analysis);
+ let trans = driver::phase_4_translate_to_llvm(tcx, &mir_map, analysis);
let crates = tcx.sess.cstore.get_used_crates(RequireDynamic);