1 /* 2 * Copyright 2018 Google Inc. All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 use std::ptr::write_bytes; 18 19 use crate::endian_scalar::{emplace_scalar, read_scalar_at}; 20 use crate::primitives::*; 21 22 /// VTableWriter compartmentalizes actions needed to create a vtable. 23 #[derive(Debug)] 24 pub struct VTableWriter<'a> { 25 buf: &'a mut [u8], 26 } 27 28 impl<'a> VTableWriter<'a> { 29 #[inline(always)] init(buf: &'a mut [u8]) -> Self30 pub fn init(buf: &'a mut [u8]) -> Self { 31 VTableWriter { buf } 32 } 33 34 /// Writes the vtable length (in bytes) into the vtable. 35 /// 36 /// Note that callers already need to have computed this to initialize 37 /// a VTableWriter. 38 /// 39 /// In debug mode, asserts that the length of the underlying data is equal 40 /// to the provided value. 41 #[inline(always)] write_vtable_byte_length(&mut self, n: VOffsetT)42 pub fn write_vtable_byte_length(&mut self, n: VOffsetT) { 43 unsafe { 44 emplace_scalar::<VOffsetT>(&mut self.buf[..SIZE_VOFFSET], n); 45 } 46 debug_assert_eq!(n as usize, self.buf.len()); 47 } 48 49 /// Writes an object length (in bytes) into the vtable. 50 #[inline(always)] write_object_inline_size(&mut self, n: VOffsetT)51 pub fn write_object_inline_size(&mut self, n: VOffsetT) { 52 unsafe { 53 emplace_scalar::<VOffsetT>(&mut self.buf[SIZE_VOFFSET..2 * SIZE_VOFFSET], n); 54 } 55 } 56 57 /// Gets an object field offset from the vtable. Only used for debugging. 58 /// 59 /// Note that this expects field offsets (which are like pointers), not 60 /// field ids (which are like array indices). 61 #[inline(always)] get_field_offset(&self, vtable_offset: VOffsetT) -> VOffsetT62 pub fn get_field_offset(&self, vtable_offset: VOffsetT) -> VOffsetT { 63 let idx = vtable_offset as usize; 64 unsafe { read_scalar_at::<VOffsetT>(&self.buf, idx) } 65 } 66 67 /// Writes an object field offset into the vtable. 68 /// 69 /// Note that this expects field offsets (which are like pointers), not 70 /// field ids (which are like array indices). 71 #[inline(always)] write_field_offset(&mut self, vtable_offset: VOffsetT, object_data_offset: VOffsetT)72 pub fn write_field_offset(&mut self, vtable_offset: VOffsetT, object_data_offset: VOffsetT) { 73 let idx = vtable_offset as usize; 74 unsafe { 75 emplace_scalar::<VOffsetT>(&mut self.buf[idx..idx + SIZE_VOFFSET], object_data_offset); 76 } 77 } 78 79 /// Clears all data in this VTableWriter. Used to cleanly undo a 80 /// vtable write. 81 #[inline(always)] clear(&mut self)82 pub fn clear(&mut self) { 83 // This is the closest thing to memset in Rust right now. 84 let len = self.buf.len(); 85 let p = self.buf.as_mut_ptr() as *mut u8; 86 unsafe { 87 write_bytes(p, 0, len); 88 } 89 } 90 } 91