let tcx = this.hir.tcx();
// Enter the remainder scope, i.e. the bindings' destruction scope.
- this.push_scope(remainder_scope, block);
+ this.push_scope(remainder_scope);
let_extent_stack.push(remainder_scope);
// Declare the bindings, which may create a visibility scope.
self.block_data_mut(block).statements.push(statement);
}
- pub fn current_location(&mut self, block: BasicBlock) -> Location {
- let index = self.block_data(block).statements.len();
- Location { block: block, statement_index: index }
- }
-
pub fn push_assign(&mut self,
block: BasicBlock,
source_info: SourceInfo,
/// see the `scope` module for more details
scopes: Vec<scope::Scope<'tcx>>,
- /// for each scope, a span of blocks that defines it;
- /// we track these for use in region and borrow checking,
- /// but these are liable to get out of date once optimization
- /// begins. They are also hopefully temporary, and will be
- /// no longer needed when we adopt graph-based regions.
- scope_auxiliary: IndexVec<ScopeId, ScopeAuxiliary>,
-
/// the current set of loops; see the `scope` module for more
/// details
loop_scopes: Vec<scope::LoopScope>,
}
}
-/// For each scope, we track the extent (from the HIR) and a
-/// single-entry-multiple-exit subgraph that contains all the
-/// statements/terminators within it.
-///
-/// This information is separated out from the main `ScopeData`
-/// because it is short-lived. First, the extent contains node-ids,
-/// so it cannot be saved and re-loaded. Second, any optimization will mess up
-/// the dominator/postdominator information.
-///
-/// The intention is basically to use this information to do
-/// regionck/borrowck and then throw it away once we are done.
-pub struct ScopeAuxiliary {
- /// extent of this scope from the MIR.
- pub extent: CodeExtent,
-
- /// "entry point": dominator of all nodes in the scope
- pub dom: Location,
-
- /// "exit points": mutual postdominators of all nodes in the scope
- pub postdoms: Vec<Location>,
-}
-
-pub type ScopeAuxiliaryVec = IndexVec<ScopeId, ScopeAuxiliary>;
-
///////////////////////////////////////////////////////////////////////////
/// The `BlockAnd` "monad" packages up the new basic block along with a
/// produced value (sometimes just unit, of course). The `unpack!`
abi: Abi,
return_ty: Ty<'gcx>,
ast_body: &'gcx hir::Expr)
- -> (Mir<'tcx>, ScopeAuxiliaryVec)
+ -> Mir<'tcx>
where A: Iterator<Item=(Ty<'gcx>, Option<&'gcx hir::Pat>)>
{
let arguments: Vec<_> = arguments.collect();
}).collect()
});
- let (mut mir, aux) = builder.finish(upvar_decls, return_ty);
+ let mut mir = builder.finish(upvar_decls, return_ty);
mir.spread_arg = spread_arg;
- (mir, aux)
+ mir
}
pub fn construct_const<'a, 'gcx, 'tcx>(hir: Cx<'a, 'gcx, 'tcx>,
item_id: ast::NodeId,
ast_expr: &'tcx hir::Expr)
- -> (Mir<'tcx>, ScopeAuxiliaryVec) {
+ -> Mir<'tcx> {
let tcx = hir.tcx();
let ty = tcx.tables().expr_ty_adjusted(ast_expr);
let span = tcx.map.span(item_id);
scopes: vec![],
visibility_scopes: IndexVec::new(),
visibility_scope: ARGUMENT_VISIBILITY_SCOPE,
- scope_auxiliary: IndexVec::new(),
loop_scopes: vec![],
local_decls: IndexVec::from_elem_n(LocalDecl::new_return_pointer(return_ty), 1),
var_indices: NodeMap(),
fn finish(self,
upvar_decls: Vec<UpvarDecl>,
return_ty: Ty<'tcx>)
- -> (Mir<'tcx>, ScopeAuxiliaryVec) {
+ -> Mir<'tcx> {
for (index, block) in self.cfg.basic_blocks.iter().enumerate() {
if block.terminator.is_none() {
span_bug!(self.fn_span, "no terminator on block {:?}", index);
}
}
- (Mir::new(self.cfg.basic_blocks,
- self.visibility_scopes,
- IndexVec::new(),
- return_ty,
- self.local_decls,
- self.arg_count,
- upvar_decls,
- self.fn_span
- ), self.scope_auxiliary)
+ Mir::new(self.cfg.basic_blocks,
+ self.visibility_scopes,
+ IndexVec::new(),
+ return_ty,
+ self.local_decls,
+ self.arg_count,
+ upvar_decls,
+ self.fn_span
+ )
}
fn args_and_body(&mut self,
*/
-use build::{BlockAnd, BlockAndExtension, Builder, CFG, ScopeAuxiliary, ScopeId};
+use build::{BlockAnd, BlockAndExtension, Builder, CFG};
use rustc::middle::region::{CodeExtent, CodeExtentData};
use rustc::middle::lang_items;
use rustc::ty::subst::{Kind, Subst};
use rustc_data_structures::fx::FxHashMap;
pub struct Scope<'tcx> {
- /// the scope-id within the scope_auxiliary
- id: ScopeId,
-
/// The visibility scope this scope was created in.
visibility_scope: VisibilityScope,
- /// the extent of this scope within source code; also stored in
- /// `ScopeAuxiliary`, but kept here for convenience
+ /// the extent of this scope within source code.
extent: CodeExtent,
/// Whether there's anything to do for the cleanup path, that is,
where F: FnOnce(&mut Builder<'a, 'gcx, 'tcx>) -> BlockAnd<R>
{
debug!("in_scope(extent={:?}, block={:?})", extent, block);
- self.push_scope(extent, block);
+ self.push_scope(extent);
let rv = unpack!(block = f(self));
unpack!(block = self.pop_scope(extent, block));
debug!("in_scope: exiting extent={:?} block={:?}", extent, block);
/// scope and call `pop_scope` afterwards. Note that these two
/// calls must be paired; using `in_scope` as a convenience
/// wrapper maybe preferable.
- pub fn push_scope(&mut self, extent: CodeExtent, entry: BasicBlock) {
+ pub fn push_scope(&mut self, extent: CodeExtent) {
debug!("push_scope({:?})", extent);
- let id = ScopeId::new(self.scope_auxiliary.len());
let vis_scope = self.visibility_scope;
self.scopes.push(Scope {
- id: id,
visibility_scope: vis_scope,
extent: extent,
needs_cleanup: false,
free: None,
cached_exits: FxHashMap()
});
- self.scope_auxiliary.push(ScopeAuxiliary {
- extent: extent,
- dom: self.cfg.current_location(entry),
- postdoms: vec![]
- });
}
/// Pops a scope, which should have extent `extent`, adding any
&self.scopes,
block,
self.arg_count));
- self.scope_auxiliary[scope.id]
- .postdoms
- .push(self.cfg.current_location(block));
block.unit()
}
self.cfg.terminate(block, scope.source_info(span), free);
block = next;
}
- self.scope_auxiliary[scope.id]
- .postdoms
- .push(self.cfg.current_location(block));
}
}
let scope = &self.scopes[len - scope_count];
impl<'a, 'gcx, 'tcx> CxBuilder<'a, 'gcx, 'tcx> {
fn build<F>(&'tcx mut self, f: F)
- where F: for<'b> FnOnce(Cx<'b, 'gcx, 'tcx>) -> (Mir<'tcx>, build::ScopeAuxiliaryVec)
+ where F: for<'b> FnOnce(Cx<'b, 'gcx, 'tcx>) -> Mir<'tcx>
{
let (src, def_id) = (self.src, self.def_id);
self.infcx.enter(|infcx| {
- let (mut mir, scope_auxiliary) = f(Cx::new(&infcx, src));
+ let mut mir = f(Cx::new(&infcx, src));
// Convert the Mir to global types.
let tcx = infcx.tcx.global_tcx();
mem::transmute::<Mir, Mir<'gcx>>(mir)
};
- pretty::dump_mir(tcx, "mir_map", &0, src, &mir, Some(&scope_auxiliary));
+ pretty::dump_mir(tcx, "mir_map", &0, src, &mir);
let mir = tcx.alloc_mir(mir);
assert!(tcx.mir_map.borrow_mut().insert(def_id, mir).is_none());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use build::{ScopeAuxiliaryVec, ScopeId};
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::mir::*;
pass_name: &str,
disambiguator: &Display,
src: MirSource,
- mir: &Mir<'tcx>,
- auxiliary: Option<&ScopeAuxiliaryVec>) {
+ mir: &Mir<'tcx>) {
let filters = match tcx.sess.opts.debugging_opts.dump_mir {
None => return,
Some(ref filters) => filters,
writeln!(file, "// pass_name = {}", pass_name)?;
writeln!(file, "// disambiguator = {}", disambiguator)?;
writeln!(file, "")?;
- write_mir_fn(tcx, src, mir, &mut file, auxiliary)?;
+ write_mir_fn(tcx, src, mir, &mut file)?;
Ok(())
});
}
let id = tcx.map.as_local_node_id(def_id).unwrap();
let src = MirSource::from_node(tcx, id);
- write_mir_fn(tcx, src, mir, w, None)?;
+ write_mir_fn(tcx, src, mir, w)?;
for (i, mir) in mir.promoted.iter_enumerated() {
writeln!(w, "")?;
- write_mir_fn(tcx, MirSource::Promoted(id, i), mir, w, None)?;
+ write_mir_fn(tcx, MirSource::Promoted(id, i), mir, w)?;
}
}
Ok(())
}
-enum Annotation {
- EnterScope(ScopeId),
- ExitScope(ScopeId),
-}
-
-fn scope_entry_exit_annotations(auxiliary: Option<&ScopeAuxiliaryVec>)
- -> FxHashMap<Location, Vec<Annotation>>
-{
- // compute scope/entry exit annotations
- let mut annotations = FxHashMap();
- if let Some(auxiliary) = auxiliary {
- for (scope_id, auxiliary) in auxiliary.iter_enumerated() {
- annotations.entry(auxiliary.dom)
- .or_insert(vec![])
- .push(Annotation::EnterScope(scope_id));
-
- for &loc in &auxiliary.postdoms {
- annotations.entry(loc)
- .or_insert(vec![])
- .push(Annotation::ExitScope(scope_id));
- }
- }
- }
- return annotations;
-}
-
pub fn write_mir_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
src: MirSource,
mir: &Mir<'tcx>,
- w: &mut Write,
- auxiliary: Option<&ScopeAuxiliaryVec>)
+ w: &mut Write)
-> io::Result<()> {
- let annotations = scope_entry_exit_annotations(auxiliary);
write_mir_intro(tcx, src, mir, w)?;
for block in mir.basic_blocks().indices() {
- write_basic_block(tcx, block, mir, w, &annotations)?;
+ write_basic_block(tcx, block, mir, w)?;
if block.index() + 1 != mir.basic_blocks().len() {
writeln!(w, "")?;
}
fn write_basic_block(tcx: TyCtxt,
block: BasicBlock,
mir: &Mir,
- w: &mut Write,
- annotations: &FxHashMap<Location, Vec<Annotation>>)
+ w: &mut Write)
-> io::Result<()> {
let data = &mir[block];
// List of statements in the middle.
let mut current_location = Location { block: block, statement_index: 0 };
for statement in &data.statements {
- if let Some(ref annotations) = annotations.get(¤t_location) {
- for annotation in annotations.iter() {
- match *annotation {
- Annotation::EnterScope(id) =>
- writeln!(w, "{0}{0}// Enter Scope({1})",
- INDENT, id.index())?,
- Annotation::ExitScope(id) =>
- writeln!(w, "{0}{0}// Exit Scope({1})",
- INDENT, id.index())?,
- }
- }
- }
-
let indented_mir = format!("{0}{0}{1:?};", INDENT, statement);
writeln!(w, "{0:1$} // {2}",
indented_mir,
is_after: is_after
},
src,
- mir,
- None
+ mir
);
}
}
projects / rust.git / commitdiff