Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-18 05:14:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

Make MallocSizeOf::malloc_{,enclosing_}size_of unsafe.

Browse source 
This fixes #18473.
This commit is contained in:
Nicholas Nethercote 2017-09-13 15:59:54 +10:00
parent cad3aff508
commit f83099f62a
3 changed files with 13 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

20
components/malloc_size_of/lib.rs
View file

@ -109,19 +109,19 @@ impl MallocSizeOfOps {
/// Call `size_of_op` on `ptr`, first checking that the allocation isn't
/// empty, because some types (such as `Vec`) utilize empty allocations.
pub fn malloc_size_of<T>(&self, ptr: *const T) -> usize {
pub unsafe fn malloc_size_of<T>(&self, ptr: *const T) -> usize {
if MallocSizeOfOps::is_empty(ptr) {
0
} else {
unsafe { (self.size_of_op)(ptr as *const c_void) }
(self.size_of_op)(ptr as *const c_void)
}
}
/// Call `enclosing_size_of_op` on `ptr`, which must not be empty.
pub fn malloc_enclosing_size_of<T>(&self, ptr: *const T) -> usize {
pub unsafe fn malloc_enclosing_size_of<T>(&self, ptr: *const T) -> usize {
assert!(!MallocSizeOfOps::is_empty(ptr));
let enclosing_size_of_op = self.enclosing_size_of_op.expect("missing enclosing_size_of_op");
unsafe { enclosing_size_of_op(ptr as *const c_void) }
enclosing_size_of_op(ptr as *const c_void)
}
/// Call `have_seen_ptr_op` on `ptr`.
@ -181,7 +181,7 @@ pub trait MallocConditionalShallowSizeOf {
impl<T> MallocShallowSizeOf for Box<T> {
fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
ops.malloc_size_of(&**self)
unsafe { ops.malloc_size_of(&**self) }
}
}
@ -209,7 +209,7 @@ impl<T: MallocSizeOf> MallocSizeOf for Option<T> {
impl<T> MallocShallowSizeOf for Vec<T> {
fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
ops.malloc_size_of(self.as_ptr())
unsafe { ops.malloc_size_of(self.as_ptr()) }
}
}
@ -226,7 +226,7 @@ impl<T: MallocSizeOf> MallocSizeOf for Vec<T> {
impl<A: Array> MallocShallowSizeOf for SmallVec<A> {
fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
if self.spilled() {
ops.malloc_size_of(self.as_ptr())
unsafe { ops.malloc_size_of(self.as_ptr()) }
} else {
0
}
@ -255,7 +255,7 @@ impl<T, S> MallocShallowSizeOf for HashSet<T, S>
// `ops.malloc_enclosing_size_of()` then gives us the storage size.
// This assumes that the `HashSet`'s contents (values and hashes) are
// all stored in a single contiguous heap allocation.
self.iter().next().map_or(0, |t| ops.malloc_enclosing_size_of(t))
self.iter().next().map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })
}
}
@ -281,7 +281,7 @@ impl<K, V, S> MallocShallowSizeOf for HashMap<K, V, S>
// `ops.malloc_enclosing_size_of()` then gives us the storage size.
// This assumes that the `HashMap`'s contents (keys, values, and
// hashes) are all stored in a single contiguous heap allocation.
self.values().next().map_or(0, |v| ops.malloc_enclosing_size_of(v))
self.values().next().map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })
}
}
@ -309,7 +309,7 @@ impl<K, V, S> MallocSizeOf for HashMap<K, V, S>
impl<T> MallocUnconditionalShallowSizeOf for Arc<T> {
fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
ops.malloc_size_of(self.heap_ptr())
unsafe { ops.malloc_size_of(self.heap_ptr()) }
}
}

4
components/style/rule_tree/mod.rs
View file

@ -67,7 +67,7 @@ impl Drop for RuleTree {
#[cfg(feature = "gecko")]
impl MallocSizeOf for RuleTree {
fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
let mut n = ops.malloc_size_of(self.root.ptr());
let mut n = unsafe { ops.malloc_size_of(self.root.ptr()) };
n += self.root.get().size_of(ops);
n
}
@ -806,7 +806,7 @@ impl MallocSizeOf for RuleNode {
fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
let mut n = 0;
for child in self.iter_children() {
n += ops.malloc_size_of(child.ptr());
n += unsafe { ops.malloc_size_of(child.ptr()) };
n += unsafe { (*child.ptr()).size_of(ops) };
}
n

2
components/style/stylesheets/style_rule.rs
View file

@ -55,7 +55,7 @@ impl StyleRule {
// It's safe to measure this ThinArc directly because it's the
// "primary" reference. (The secondary references are on the
// Stylist.)
n += ops.malloc_size_of(selector.thin_arc_heap_ptr());
n += unsafe { ops.malloc_size_of(selector.thin_arc_heap_ptr()) };
}
n += self.block.unconditional_shallow_size_of(ops) +