From f0c67951d076db8272f7a52f4d2596ae77b3311d Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Fri, 13 Jul 2018 10:53:57 +1000 Subject: [PATCH] Make BitSlice's `Word` properly generic. Currently `Word` is `usize`, and there are various places in the code that assume this. This patch mostly just changes `usize` occurrences to `Word`. Most of the changes were found as compile errors when I changed `Word` to a type other than `usize`, but there was one non-obvious case in librustc_mir/dataflow/mod.rs that caused bounds check failures before I fixed it. --- src/librustc_data_structures/bitslice.rs | 14 +++++++------- src/librustc_mir/dataflow/impls/borrowed_locals.rs | 2 +- src/librustc_mir/dataflow/impls/borrows.rs | 4 ++-- src/librustc_mir/dataflow/impls/mod.rs | 12 ++++++------ .../dataflow/impls/storage_liveness.rs | 2 +- src/librustc_mir/dataflow/mod.rs | 10 +++++----- 6 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/librustc_data_structures/bitslice.rs b/src/librustc_data_structures/bitslice.rs index 2678861be06..5b5dd907cb7 100644 --- a/src/librustc_data_structures/bitslice.rs +++ b/src/librustc_data_structures/bitslice.rs @@ -79,7 +79,7 @@ fn bit_lookup(bit: usize) -> BitLookup { } -fn bit_str(bit: Word) -> String { +fn bit_str(bit: usize) -> String { let byte = bit >> 3; let lobits = 1 << (bit & 0b111); format!("[{}:{}-{:02x}]", bit, byte, lobits) @@ -116,8 +116,8 @@ pub fn bits_to_string(words: &[Word], bits: usize) -> String { } #[inline] -pub fn bitwise(out_vec: &mut [usize], - in_vec: &[usize], +pub fn bitwise(out_vec: &mut [Word], + in_vec: &[Word], op: &Op) -> bool { assert_eq!(out_vec.len(), in_vec.len()); let mut changed = false; @@ -132,21 +132,21 @@ pub fn bitwise(out_vec: &mut [usize], pub trait BitwiseOperator { /// Applies some bit-operation pointwise to each of the bits in the two inputs. - fn join(&self, pred1: usize, pred2: usize) -> usize; + fn join(&self, pred1: Word, pred2: Word) -> Word; } pub struct Intersect; impl BitwiseOperator for Intersect { #[inline] - fn join(&self, a: usize, b: usize) -> usize { a & b } + fn join(&self, a: Word, b: Word) -> Word { a & b } } pub struct Union; impl BitwiseOperator for Union { #[inline] - fn join(&self, a: usize, b: usize) -> usize { a | b } + fn join(&self, a: Word, b: Word) -> Word { a | b } } pub struct Subtract; impl BitwiseOperator for Subtract { #[inline] - fn join(&self, a: usize, b: usize) -> usize { a & !b } + fn join(&self, a: Word, b: Word) -> Word { a & !b } } diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs index 244e8b5ccd7..c7513ac8816 100644 --- a/src/librustc_mir/dataflow/impls/borrowed_locals.rs +++ b/src/librustc_mir/dataflow/impls/borrowed_locals.rs @@ -74,7 +74,7 @@ impl<'a, 'tcx> BitDenotation for HaveBeenBorrowedLocals<'a, 'tcx> { impl<'a, 'tcx> BitwiseOperator for HaveBeenBorrowedLocals<'a, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // "maybe" means we union effects of both preds } } diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs index a109389aa31..dbdf5b4e096 100644 --- a/src/librustc_mir/dataflow/impls/borrows.rs +++ b/src/librustc_mir/dataflow/impls/borrows.rs @@ -20,7 +20,7 @@ use rustc::ty::TyCtxt; use rustc::ty::{RegionKind, RegionVid}; use rustc::ty::RegionKind::ReScope; -use rustc_data_structures::bitslice::BitwiseOperator; +use rustc_data_structures::bitslice::{BitwiseOperator, Word}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::indexed_set::IdxSet; use rustc_data_structures::indexed_vec::IndexVec; @@ -370,7 +370,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation for Borrows<'a, 'gcx, 'tcx> { impl<'a, 'gcx, 'tcx> BitwiseOperator for Borrows<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // union effects of preds when computing reservations } } diff --git a/src/librustc_mir/dataflow/impls/mod.rs b/src/librustc_mir/dataflow/impls/mod.rs index f64fd64b283..ee3bba840c6 100644 --- a/src/librustc_mir/dataflow/impls/mod.rs +++ b/src/librustc_mir/dataflow/impls/mod.rs @@ -14,7 +14,7 @@ use rustc::ty::TyCtxt; use rustc::mir::{self, Mir, Location}; -use rustc_data_structures::bitslice::{BitwiseOperator}; +use rustc_data_structures::bitslice::{BitwiseOperator, Word}; use rustc_data_structures::indexed_set::{IdxSet}; use rustc_data_structures::indexed_vec::Idx; @@ -663,35 +663,35 @@ impl<'a, 'gcx, 'tcx> BitDenotation for EverInitializedPlaces<'a, 'gcx, 'tcx> { impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeInitializedPlaces<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // "maybe" means we union effects of both preds } } impl<'a, 'gcx, 'tcx> BitwiseOperator for MaybeUninitializedPlaces<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // "maybe" means we union effects of both preds } } impl<'a, 'gcx, 'tcx> BitwiseOperator for DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 & pred2 // "definitely" means we intersect effects of both preds } } impl<'a, 'gcx, 'tcx> BitwiseOperator for MovingOutStatements<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // moves from both preds are in scope } } impl<'a, 'gcx, 'tcx> BitwiseOperator for EverInitializedPlaces<'a, 'gcx, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // inits from both preds are in scope } } diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs index dea61542ac4..29548051a4d 100644 --- a/src/librustc_mir/dataflow/impls/storage_liveness.rs +++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs @@ -69,7 +69,7 @@ impl<'a, 'tcx> BitDenotation for MaybeStorageLive<'a, 'tcx> { impl<'a, 'tcx> BitwiseOperator for MaybeStorageLive<'a, 'tcx> { #[inline] - fn join(&self, pred1: usize, pred2: usize) -> usize { + fn join(&self, pred1: Word, pred2: Word) -> Word { pred1 | pred2 // "maybe" means we union effects of both preds } } diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs index e59236c5168..f58609aa9a5 100644 --- a/src/librustc_mir/dataflow/mod.rs +++ b/src/librustc_mir/dataflow/mod.rs @@ -12,7 +12,7 @@ use syntax::ast::{self, MetaItem}; use rustc_data_structures::indexed_set::{IdxSet, IdxSetBuf}; use rustc_data_structures::indexed_vec::Idx; -use rustc_data_structures::bitslice::{bitwise, BitwiseOperator}; +use rustc_data_structures::bitslice::{bitwise, BitwiseOperator, Word}; use rustc_data_structures::work_queue::WorkQueue; use rustc::ty::{self, TyCtxt}; @@ -467,7 +467,7 @@ pub struct AllSets { bits_per_block: usize, /// Number of words associated with each block entry - /// equal to bits_per_block / usize::BITS, rounded up. + /// equal to bits_per_block / (mem::size_of:: * 8), rounded up. words_per_block: usize, /// For each block, bits generated by executing the statements in @@ -734,9 +734,9 @@ impl<'a, 'tcx, D> DataflowAnalysis<'a, 'tcx, D> where D: BitDenotation dead_unwinds: &'a IdxSet, denotation: D) -> Self where D: InitialFlow { let bits_per_block = denotation.bits_per_block(); - let usize_bits = mem::size_of::() * 8; - let words_per_block = (bits_per_block + usize_bits - 1) / usize_bits; - let bits_per_block_rounded_up = words_per_block * usize_bits; // a multiple of word size + let bits_per_word = mem::size_of::() * 8; + let words_per_block = (bits_per_block + bits_per_word - 1) / bits_per_word; + let bits_per_block_rounded_up = words_per_block * bits_per_word; // a multiple of word size let num_blocks = mir.basic_blocks().len(); let num_overall = num_blocks * bits_per_block_rounded_up;