// except according to those terms.
use rustc_data_structures::bitvec::BitVector;
-use rustc_data_structures::indexed_vec::Idx;
use super::*;
#[derive(Clone)]
pub struct Preorder<'a, 'tcx: 'a> {
mir: &'a Mir<'tcx>,
- visited: BitVector,
+ visited: BitVector<BasicBlock>,
worklist: Vec<BasicBlock>,
}
fn next(&mut self) -> Option<(BasicBlock, &'a BasicBlockData<'tcx>)> {
while let Some(idx) = self.worklist.pop() {
- if !self.visited.insert(idx.index()) {
+ if !self.visited.insert(idx) {
continue;
}
/// A Postorder traversal of this graph is `D B C A` or `D C B A`
pub struct Postorder<'a, 'tcx: 'a> {
mir: &'a Mir<'tcx>,
- visited: BitVector,
+ visited: BitVector<BasicBlock>,
visit_stack: Vec<(BasicBlock, Successors<'a>)>
}
let data = &po.mir[root];
if let Some(ref term) = data.terminator {
- po.visited.insert(root.index());
+ po.visited.insert(root);
po.visit_stack.push((root, term.successors()));
po.traverse_successor();
}
break;
};
- if self.visited.insert(bb.index()) {
- if let Some(ref term) = self.mir[bb].terminator {
+ if self.visited.insert(bb) {
+ if let Some(term) = &self.mir[bb].terminator {
self.visit_stack.push((bb, term.successors()));
}
}
let mut has_variables = BitVector::new(mir.source_scopes.len());
for var in mir.vars_iter() {
let decl = &mir.local_decls[var];
- has_variables.insert(decl.visibility_scope.index());
+ has_variables.insert(decl.visibility_scope);
}
// Instantiate all scopes.
fn make_mir_scope(cx: &CodegenCx,
mir: &Mir,
- has_variables: &BitVector,
+ has_variables: &BitVector<SourceScope>,
debug_context: &FunctionDebugContextData,
scope: SourceScope,
scopes: &mut IndexVec<SourceScope, MirDebugScope>) {
return;
};
- if !has_variables.contains(scope.index()) {
+ if !has_variables.contains(scope) {
// Do not create a DIScope if there are no variables
// defined in this MIR Scope, to avoid debuginfo bloat.
use type_of::LayoutLlvmExt;
use super::FunctionCx;
-pub fn non_ssa_locals<'a, 'tcx>(fx: &FunctionCx<'a, 'tcx>) -> BitVector {
+pub fn non_ssa_locals<'a, 'tcx>(fx: &FunctionCx<'a, 'tcx>) -> BitVector<mir::Local> {
let mir = fx.mir;
let mut analyzer = LocalAnalyzer::new(fx);
struct LocalAnalyzer<'mir, 'a: 'mir, 'tcx: 'a> {
fx: &'mir FunctionCx<'a, 'tcx>,
dominators: Dominators<mir::BasicBlock>,
- non_ssa_locals: BitVector,
+ non_ssa_locals: BitVector<mir::Local>,
// The location of the first visited direct assignment to each
// local, or an invalid location (out of bounds `block` index).
first_assignment: IndexVec<mir::Local, Location>
fn not_ssa(&mut self, local: mir::Local) {
debug!("marking {:?} as non-SSA", local);
- self.non_ssa_locals.insert(local.index());
+ self.non_ssa_locals.insert(local);
}
fn assign(&mut self, local: mir::Local, location: Location) {
let debug_scope = fx.scopes[decl.visibility_scope];
let dbg = debug_scope.is_valid() && bx.sess().opts.debuginfo == FullDebugInfo;
- if !memory_locals.contains(local.index()) && !dbg {
+ if !memory_locals.contains(local) && !dbg {
debug!("alloc: {:?} ({}) -> operand", local, name);
return LocalRef::new_operand(bx.cx, layout);
}
debug!("alloc: {:?} (return place) -> place", local);
let llretptr = llvm::get_param(llfn, 0);
LocalRef::Place(PlaceRef::new_sized(llretptr, layout, layout.align))
- } else if memory_locals.contains(local.index()) {
+ } else if memory_locals.contains(local) {
debug!("alloc: {:?} -> place", local);
LocalRef::Place(PlaceRef::alloca(&bx, layout, &format!("{:?}", local)))
} else {
fn arg_local_refs<'a, 'tcx>(bx: &Builder<'a, 'tcx>,
fx: &FunctionCx<'a, 'tcx>,
scopes: &IndexVec<mir::SourceScope, debuginfo::MirDebugScope>,
- memory_locals: &BitVector)
+ memory_locals: &BitVector<mir::Local>)
-> Vec<LocalRef<'tcx>> {
let mir = fx.mir;
let tcx = bx.tcx();
llarg_idx += 1;
}
- if arg_scope.is_none() && !memory_locals.contains(local.index()) {
+ if arg_scope.is_none() && !memory_locals.contains(local) {
// We don't have to cast or keep the argument in the alloca.
// FIXME(eddyb): We should figure out how to use llvm.dbg.value instead
// of putting everything in allocas just so we can use llvm.dbg.declare.
/// A very simple BitVector type.
#[derive(Clone, Debug, PartialEq)]
-pub struct BitVector {
+pub struct BitVector<C: Idx> {
data: Vec<Word>,
+ marker: PhantomData<C>,
}
-impl BitVector {
+impl<C: Idx> BitVector<C> {
#[inline]
- pub fn new(num_bits: usize) -> BitVector {
+ pub fn new(num_bits: usize) -> BitVector<C> {
let num_words = words(num_bits);
BitVector {
data: vec![0; num_words],
+ marker: PhantomData,
}
}
}
#[inline]
- pub fn contains(&self, bit: usize) -> bool {
+ pub fn contains(&self, bit: C) -> bool {
let (word, mask) = word_mask(bit);
(self.data[word] & mask) != 0
}
/// Returns true if the bit has changed.
#[inline]
- pub fn insert(&mut self, bit: usize) -> bool {
+ pub fn insert(&mut self, bit: C) -> bool {
let (word, mask) = word_mask(bit);
let data = &mut self.data[word];
let value = *data;
/// Returns true if the bit has changed.
#[inline]
- pub fn remove(&mut self, bit: usize) -> bool {
+ pub fn remove(&mut self, bit: C) -> bool {
let (word, mask) = word_mask(bit);
let data = &mut self.data[word];
let value = *data;
}
#[inline]
- pub fn merge(&mut self, all: &BitVector) -> bool {
+ pub fn merge(&mut self, all: &BitVector<C>) -> bool {
assert!(self.data.len() == all.data.len());
let mut changed = false;
for (i, j) in self.data.iter_mut().zip(&all.data) {
}
#[inline]
- pub fn grow(&mut self, num_bits: usize) {
+ pub fn grow(&mut self, num_bits: C) {
let num_words = words(num_bits);
if self.data.len() < num_words {
self.data.resize(num_words, 0)
/// Iterates over indexes of set bits in a sorted order
#[inline]
- pub fn iter<'a>(&'a self) -> BitVectorIter<'a> {
+ pub fn iter<'a>(&'a self) -> BitVectorIter<'a, C> {
BitVectorIter {
iter: self.data.iter(),
current: 0,
idx: 0,
+ marker: PhantomData,
}
}
}
-pub struct BitVectorIter<'a> {
+pub struct BitVectorIter<'a, C: Idx> {
iter: ::std::slice::Iter<'a, Word>,
current: Word,
idx: usize,
+ marker: PhantomData<C>
}
-impl<'a> Iterator for BitVectorIter<'a> {
- type Item = usize;
- fn next(&mut self) -> Option<usize> {
+impl<'a, C: Idx> Iterator for BitVectorIter<'a, C> {
+ type Item = C;
+ fn next(&mut self) -> Option<C> {
while self.current == 0 {
self.current = if let Some(&i) = self.iter.next() {
if i == 0 {
self.current >>= offset;
self.current >>= 1; // shift otherwise overflows for 0b1000_0000_…_0000
self.idx += offset + 1;
- return Some(self.idx - 1);
+ return Some(C::new(self.idx - 1));
}
fn size_hint(&self) -> (usize, Option<usize>) {
}
}
-impl FromIterator<bool> for BitVector {
- fn from_iter<I>(iter: I) -> BitVector
+impl<C: Idx> FromIterator<bool> for BitVector<C> {
+ fn from_iter<I>(iter: I) -> BitVector<C>
where
I: IntoIterator<Item = bool>,
{
let mut bv = BitVector::new(len);
for (idx, val) in iter.enumerate() {
if idx > len {
- bv.grow(idx);
+ bv.grow(C::new(idx));
}
if val {
- bv.insert(idx);
+ bv.insert(C::new(idx));
}
}
/// one gigantic bitvector. In other words, it is as if you have
/// `rows` bitvectors, each of length `columns`.
#[derive(Clone, Debug)]
-pub struct BitMatrix {
+pub struct BitMatrix<R: Idx, C: Idx> {
columns: usize,
vector: Vec<Word>,
+ phantom: PhantomData<(R, C)>,
}
-impl BitMatrix {
+impl<R: Idx, C: Idx> BitMatrix<R, C> {
/// Create a new `rows x columns` matrix, initially empty.
- pub fn new(rows: usize, columns: usize) -> BitMatrix {
+ pub fn new(rows: usize, columns: usize) -> BitMatrix<R, C> {
// For every element, we need one bit for every other
// element. Round up to an even number of words.
let words_per_row = words(columns);
BitMatrix {
columns,
vector: vec![0; rows * words_per_row],
+ phantom: PhantomData,
}
}
/// The range of bits for a given row.
- fn range(&self, row: usize) -> (usize, usize) {
+ fn range(&self, row: R) -> (usize, usize) {
+ let row = row.index();
let words_per_row = words(self.columns);
let start = row * words_per_row;
(start, start + words_per_row)
/// `column` to the bitset for `row`.
///
/// Returns true if this changed the matrix, and false otherwise.
- pub fn add(&mut self, row: usize, column: usize) -> bool {
+ pub fn add(&mut self, row: R, column: R) -> bool {
let (start, _) = self.range(row);
let (word, mask) = word_mask(column);
let vector = &mut self.vector[..];
/// the matrix cell at `(row, column)` true? Put yet another way,
/// if the matrix represents (transitive) reachability, can
/// `row` reach `column`?
- pub fn contains(&self, row: usize, column: usize) -> bool {
+ pub fn contains(&self, row: R, column: R) -> bool {
let (start, _) = self.range(row);
let (word, mask) = word_mask(column);
(self.vector[start + word] & mask) != 0
/// is an O(n) operation where `n` is the number of elements
/// (somewhat independent from the actual size of the
/// intersection, in particular).
- pub fn intersection(&self, a: usize, b: usize) -> Vec<usize> {
+ pub fn intersection(&self, a: R, b: R) -> Vec<C> {
let (a_start, a_end) = self.range(a);
let (b_start, b_end) = self.range(b);
let mut result = Vec::with_capacity(self.columns);
break;
}
if v & 0x1 != 0 {
- result.push(base * WORD_BITS + bit);
+ result.push(C::new(base * WORD_BITS + bit));
}
v >>= 1;
}
/// you have an edge `write -> read`, because in that case
/// `write` can reach everything that `read` can (and
/// potentially more).
- pub fn merge(&mut self, read: usize, write: usize) -> bool {
+ pub fn merge(&mut self, read: R, write: R) -> bool {
let (read_start, read_end) = self.range(read);
let (write_start, write_end) = self.range(write);
let vector = &mut self.vector[..];
/// Iterates through all the columns set to true in a given row of
/// the matrix.
- pub fn iter<'a>(&'a self, row: usize) -> BitVectorIter<'a> {
+ pub fn iter<'a>(&'a self, row: R) -> BitVectorIter<'a, C> {
let (start, end) = self.range(row);
BitVectorIter {
iter: self.vector[start..end].iter(),
current: 0,
idx: 0,
+ marker: PhantomData,
}
}
}
C: Idx,
{
columns: usize,
- vector: IndexVec<R, BitVector>,
- marker: PhantomData<C>,
+ vector: IndexVec<R, BitVector<C>>,
}
impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
Self {
columns,
vector: IndexVec::new(),
- marker: PhantomData,
}
}
let columns = self.columns;
self.vector
.ensure_contains_elem(row, || BitVector::new(columns));
- self.vector[row].insert(column.index())
+ self.vector[row].insert(column)
}
/// Do the bits from `row` contain `column`? Put another way, is
/// if the matrix represents (transitive) reachability, can
/// `row` reach `column`?
pub fn contains(&self, row: R, column: C) -> bool {
- self.vector.get(row).map_or(false, |r| r.contains(column.index()))
+ self.vector.get(row).map_or(false, |r| r.contains(column))
}
/// Add the bits from row `read` to the bits from row `write`,
}
/// Merge a row, `from`, into the `into` row.
- pub fn merge_into(&mut self, into: R, from: &BitVector) -> bool {
+ pub fn merge_into(&mut self, into: R, from: &BitVector<C>) -> bool {
let columns = self.columns;
self.vector
.ensure_contains_elem(into, || BitVector::new(columns));
/// Iterates through all the columns set to true in a given row of
/// the matrix.
pub fn iter<'a>(&'a self, row: R) -> impl Iterator<Item = C> + 'a {
- self.vector.get(row).into_iter().flat_map(|r| r.iter().map(|n| C::new(n)))
+ self.vector.get(row).into_iter().flat_map(|r| r.iter())
}
/// Iterates through each row and the accompanying bit set.
- pub fn iter_enumerated<'a>(&'a self) -> impl Iterator<Item = (R, &'a BitVector)> + 'a {
+ pub fn iter_enumerated<'a>(&'a self) -> impl Iterator<Item = (R, &'a BitVector<C>)> + 'a {
self.vector.iter_enumerated()
}
+
+ pub fn row(&self, row: R) -> Option<&BitVector<C>> {
+ self.vector.get(row)
+ }
}
#[inline]
-fn words(elements: usize) -> usize {
- (elements + WORD_BITS - 1) / WORD_BITS
+fn words<C: Idx>(elements: C) -> usize {
+ (elements.index() + WORD_BITS - 1) / WORD_BITS
}
#[inline]
-fn word_mask(index: usize) -> (usize, Word) {
+fn word_mask<C: Idx>(index: C) -> (usize, Word) {
+ let index = index.index();
let word = index / WORD_BITS;
let mask = 1 << (index % WORD_BITS);
(word, mask)
{
graph: &'g Graph<N, E>,
stack: Vec<NodeIndex>,
- visited: BitVector,
+ visited: BitVector<usize>,
direction: Direction,
}
/// (purpose: avoid mixing indexes for different bitvector domains.)
pub trait Idx: Copy + 'static + Ord + Debug + Hash {
fn new(idx: usize) -> Self;
+
fn index(self) -> usize;
+
+ fn increment_by(&mut self, amount: usize) {
+ let v = self.index() + amount;
+ *self = Self::new(v);
+ }
}
impl Idx for usize {
}
#[inline]
- pub fn swap(&mut self, a: usize, b: usize) {
- self.raw.swap(a, b)
+ pub fn swap(&mut self, a: I, b: I) {
+ self.raw.swap(a.index(), b.index())
}
#[inline]
// are added with new elements. Perhaps better would be to ask the
// user for a batch of edges to minimize this effect, but I
// already wrote the code this way. :P -nmatsakis
- closure: Lock<Option<BitMatrix>>,
+ closure: Lock<Option<BitMatrix<usize, usize>>>,
}
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)]
}
fn with_closure<OP, R>(&self, op: OP) -> R
- where OP: FnOnce(&BitMatrix) -> R
+ where OP: FnOnce(&BitMatrix<usize, usize>) -> R
{
let mut closure_cell = self.closure.borrow_mut();
let mut closure = closure_cell.take();
result
}
- fn compute_closure(&self) -> BitMatrix {
+ fn compute_closure(&self) -> BitMatrix<usize, usize> {
let mut matrix = BitMatrix::new(self.elements.len(),
self.elements.len());
let mut changed = true;
/// - Input: `[a, b, x]`. Output: `[a, x]`.
/// - Input: `[b, a, x]`. Output: `[b, a, x]`.
/// - Input: `[a, x, b, y]`. Output: `[a, x]`.
-fn pare_down(candidates: &mut Vec<usize>, closure: &BitMatrix) {
+fn pare_down(candidates: &mut Vec<usize>, closure: &BitMatrix<usize, usize>) {
let mut i = 0;
while i < candidates.len() {
let candidate_i = candidates[i];
/// Iterates through each row and the accompanying bit set.
pub fn iter_enumerated<'a>(
&'a self
- ) -> impl Iterator<Item = (N, &'a BitVector)> + 'a {
+ ) -> impl Iterator<Item = (N, &'a BitVector<RegionElementIndex>)> + 'a {
self.matrix.iter_enumerated()
}
/// Merge a row, `from`, originating in another `RegionValues` into the `into` row.
- pub fn merge_into(&mut self, into: N, from: &BitVector) -> bool {
+ pub fn merge_into(&mut self, into: N, from: &BitVector<RegionElementIndex>) -> bool {
self.matrix.merge_into(into, from)
}
// test the branches of enum
Switch {
adt_def: &'tcx ty::AdtDef,
- variants: BitVector,
+ variants: BitVector<usize>,
},
// test the branches of enum
pub fn add_variants_to_switch<'pat>(&mut self,
test_place: &Place<'tcx>,
candidate: &Candidate<'pat, 'tcx>,
- variants: &mut BitVector)
+ variants: &mut BitVector<usize>)
-> bool
{
let match_pair = match candidate.match_pairs.iter().find(|mp| mp.place == *test_place) {
// Contains one bit per mono item in the `targets` field. That bit
// is true if that mono item needs to be inlined into every CGU.
- inlines: BitVector,
+ inlines: BitVector<usize>,
}
impl<'tcx> InliningMap<'tcx> {
DerefArgVisitor.visit_mir(mir);
}
-fn replace_result_variable<'tcx>(ret_ty: Ty<'tcx>,
- mir: &mut Mir<'tcx>) -> Local {
+fn replace_result_variable<'tcx>(
+ ret_ty: Ty<'tcx>,
+ mir: &mut Mir<'tcx>,
+) -> Local {
let source_info = source_info(mir);
let new_ret = LocalDecl {
mutability: Mutability::Mut,
};
let new_ret_local = Local::new(mir.local_decls.len());
mir.local_decls.push(new_ret);
- mir.local_decls.swap(0, new_ret_local.index());
+ mir.local_decls.swap(RETURN_PLACE, new_ret_local);
RenameLocalVisitor {
from: RETURN_PLACE,
param_env: ty::ParamEnv<'tcx>,
local_qualif: IndexVec<Local, Option<Qualif>>,
qualif: Qualif,
- const_fn_arg_vars: BitVector,
+ const_fn_arg_vars: BitVector<Local>,
temp_promotion_state: IndexVec<Local, TempState>,
promotion_candidates: Vec<Candidate>
}
// Make sure there are no extra unassigned variables.
self.qualif = Qualif::NOT_CONST;
for index in mir.vars_iter() {
- if !self.const_fn_arg_vars.contains(index.index()) {
+ if !self.const_fn_arg_vars.contains(index) {
debug!("unassigned variable {:?}", index);
self.assign(&Place::Local(index), Location {
block: bb,
// Check the allowed const fn argument forms.
if let (Mode::ConstFn, &Place::Local(index)) = (self.mode, dest) {
if self.mir.local_kind(index) == LocalKind::Var &&
- self.const_fn_arg_vars.insert(index.index()) &&
+ self.const_fn_arg_vars.insert(index) &&
!self.tcx.sess.features_untracked().const_let {
// Direct use of an argument is permitted.
use rustc::ty::TyCtxt;
use rustc::mir::*;
use rustc_data_structures::bitvec::BitVector;
-use rustc_data_structures::indexed_vec::Idx;
use transform::{MirPass, MirSource};
use util::patch::MirPatch;
}
impl RemoveNoopLandingPads {
- fn is_nop_landing_pad(&self, bb: BasicBlock, mir: &Mir, nop_landing_pads: &BitVector)
- -> bool
- {
+ fn is_nop_landing_pad(
+ &self,
+ bb: BasicBlock,
+ mir: &Mir,
+ nop_landing_pads: &BitVector<BasicBlock>,
+ ) -> bool {
for stmt in &mir[bb].statements {
match stmt.kind {
StatementKind::ReadForMatch(_) |
TerminatorKind::SwitchInt { .. } |
TerminatorKind::FalseEdges { .. } |
TerminatorKind::FalseUnwind { .. } => {
- terminator.successors().all(|succ| {
- nop_landing_pads.contains(succ.index())
+ terminator.successors().all(|&succ| {
+ nop_landing_pads.contains(succ)
})
},
TerminatorKind::GeneratorDrop |
for bb in postorder {
debug!(" processing {:?}", bb);
for target in mir[bb].terminator_mut().successors_mut() {
- if *target != resume_block && nop_landing_pads.contains(target.index()) {
+ if *target != resume_block && nop_landing_pads.contains(*target) {
debug!(" folding noop jump to {:?} to resume block", target);
*target = resume_block;
jumps_folded += 1;
let is_nop_landing_pad = self.is_nop_landing_pad(bb, mir, &nop_landing_pads);
if is_nop_landing_pad {
- nop_landing_pads.insert(bb.index());
+ nop_landing_pads.insert(bb);
}
debug!(" is_nop_landing_pad({:?}) = {}", bb, is_nop_landing_pad);
}
let mut marker = DeclMarker { locals: BitVector::new(mir.local_decls.len()) };
marker.visit_mir(mir);
// Return pointer and arguments are always live
- marker.locals.insert(RETURN_PLACE.index());
+ marker.locals.insert(RETURN_PLACE);
for arg in mir.args_iter() {
- marker.locals.insert(arg.index());
+ marker.locals.insert(arg);
}
// We may need to keep dead user variables live for debuginfo.
if tcx.sess.opts.debuginfo == FullDebugInfo {
for local in mir.vars_iter() {
- marker.locals.insert(local.index());
+ marker.locals.insert(local);
}
}
}
/// Construct the mapping while swapping out unused stuff out from the `vec`.
-fn make_local_map<'tcx, I: Idx, V>(vec: &mut IndexVec<I, V>, mask: BitVector) -> Vec<usize> {
- let mut map: Vec<usize> = ::std::iter::repeat(!0).take(vec.len()).collect();
- let mut used = 0;
+fn make_local_map<'tcx, V>(
+ vec: &mut IndexVec<Local, V>,
+ mask: BitVector<Local>,
+) -> IndexVec<Local, Option<Local>> {
+ let mut map: IndexVec<Local, Option<Local>> = IndexVec::from_elem(None, &*vec);
+ let mut used = Local::new(0);
for alive_index in mask.iter() {
- map[alive_index] = used;
+ map[alive_index] = Some(used);
if alive_index != used {
vec.swap(alive_index, used);
}
- used += 1;
+ used.increment_by(1);
}
- vec.truncate(used);
+ vec.truncate(used.index());
map
}
struct DeclMarker {
- pub locals: BitVector,
+ pub locals: BitVector<Local>,
}
impl<'tcx> Visitor<'tcx> for DeclMarker {
fn visit_local(&mut self, local: &Local, ctx: PlaceContext<'tcx>, _: Location) {
// ignore these altogether, they get removed along with their otherwise unused decls.
if ctx != PlaceContext::StorageLive && ctx != PlaceContext::StorageDead {
- self.locals.insert(local.index());
+ self.locals.insert(*local);
}
}
}
struct LocalUpdater {
- map: Vec<usize>,
+ map: IndexVec<Local, Option<Local>>,
}
impl<'tcx> MutVisitor<'tcx> for LocalUpdater {
data.statements.retain(|stmt| {
match stmt.kind {
StatementKind::StorageLive(l) | StatementKind::StorageDead(l) => {
- self.map[l.index()] != !0
+ self.map[l].is_some()
}
_ => true
}
self.super_basic_block_data(block, data);
}
fn visit_local(&mut self, l: &mut Local, _: PlaceContext<'tcx>, _: Location) {
- *l = Local::new(self.map[l.index()]);
+ *l = self.map[*l].unwrap();
}
}
projects / rust.git / commitdiff