//! and thus uses bitvectors. Your job is simply to specify the so-called
//! GEN and KILL bits for each expression.
-pub use self::EntryOrExit::*;
-
use middle::cfg;
use middle::cfg::CFGIndex;
use middle::ty;
use std::io;
+use std::mem;
use std::usize;
use syntax::ast;
use syntax::ast_util::IdRange;
use syntax::print::pprust::PrintState;
use util::nodemap::NodeMap;
use rustc_front::hir;
-use rustc_front::visit;
+use rustc_front::intravisit;
use rustc_front::print::pprust;
index: &'a mut NodeMap<Vec<CFGIndex>>,
}
let mut formals = Formals { entry: entry, index: index };
- visit::walk_fn_decl(&mut formals, decl);
- impl<'a, 'v> visit::Visitor<'v> for Formals<'a> {
+ intravisit::walk_fn_decl(&mut formals, decl);
+ impl<'a, 'v> intravisit::Visitor<'v> for Formals<'a> {
fn visit_pat(&mut self, p: &hir::Pat) {
self.index.entry(p.id).or_insert(vec![]).push(self.entry);
- visit::walk_pat(self, p)
+ intravisit::walk_pat(self, p)
}
}
}
oper: O,
id_range: IdRange,
bits_per_id: usize) -> DataFlowContext<'a, 'tcx, O> {
- let words_per_id = (bits_per_id + usize::BITS - 1) / usize::BITS;
+ let usize_bits = mem::size_of::<usize>() * 8;
+ let words_per_id = (bits_per_id + usize_bits - 1) / usize_bits;
let num_nodes = cfg.graph.all_nodes().len();
debug!("DataFlowContext::new(analysis_name: {}, id_range={:?}, \
}
let indices = get_cfg_indices(id, &self.nodeid_to_index);
for &cfgidx in indices {
- if !self.each_bit_for_node(Entry, cfgidx, |i| f(i)) {
+ if !self.each_bit_for_node(EntryOrExit::Entry, cfgidx, |i| f(i)) {
return false;
}
}
let on_entry = &self.on_entry[start.. end];
let temp_bits;
let slice = match e {
- Entry => on_entry,
- Exit => {
+ EntryOrExit::Entry => on_entry,
+ EntryOrExit::Exit => {
let mut t = on_entry.to_vec();
self.apply_gen_kill(cfgidx, &mut t);
temp_bits = t;
//! Returns false on the first call to `f` that returns false;
//! if all calls to `f` return true, then returns true.
+ let usize_bits = mem::size_of::<usize>() * 8;
for (word_index, &word) in words.iter().enumerate() {
if word != 0 {
- let base_index = word_index * usize::BITS;
- for offset in 0..usize::BITS {
+ let base_index = word_index * usize_bits;
+ for offset in 0..usize_bits {
let bit = 1 << offset;
if (word & bit) != 0 {
// NB: we round up the total number of bits
debug!("{}", {
let mut v = Vec::new();
self.pretty_print_to(box &mut v, blk).unwrap();
- println!("{}", String::from_utf8(v).unwrap());
- ""
+ String::from_utf8(v).unwrap()
});
}
fn pretty_print_to<'b>(&self, wr: Box<io::Write + 'b>,
blk: &hir::Block) -> io::Result<()> {
- let mut ps = pprust::rust_printer_annotated(wr, self);
+ let mut ps = pprust::rust_printer_annotated(wr, self, None);
try!(ps.cbox(pprust::indent_unit));
try!(ps.ibox(0));
try!(ps.print_block(blk));
for &word in words {
let mut v = word;
- for _ in 0..usize::BYTES {
+ for _ in 0..mem::size_of::<usize>() {
result.push(sep);
result.push_str(&format!("{:02x}", v & 0xFF));
v >>= 8;
fn set_bit(words: &mut [usize], bit: usize) -> bool {
debug!("set_bit: words={} bit={}",
mut_bits_to_string(words), bit_str(bit));
- let word = bit / usize::BITS;
- let bit_in_word = bit % usize::BITS;
+ let usize_bits = mem::size_of::<usize>() * 8;
+ let word = bit / usize_bits;
+ let bit_in_word = bit % usize_bits;
let bit_mask = 1 << bit_in_word;
debug!("word={} bit_in_word={} bit_mask={}", word, bit_in_word, word);
let oldv = words[word];