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 endian_scalar::{emplace_scalar, read_scalar_at}; 20 use 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 emplace_scalar::<VOffsetT>(&mut self.buf[..SIZE_VOFFSET], n); 44 debug_assert_eq!(n as usize, self.buf.len()); 45 } 46 47 /// Writes an object length (in bytes) into the vtable. 48 #[inline(always)] write_object_inline_size(&mut self, n: VOffsetT)49 pub fn write_object_inline_size(&mut self, n: VOffsetT) { 50 emplace_scalar::<VOffsetT>(&mut self.buf[SIZE_VOFFSET..2 * SIZE_VOFFSET], n); 51 } 52 53 /// Gets an object field offset from the vtable. Only used for debugging. 54 /// 55 /// Note that this expects field offsets (which are like pointers), not 56 /// field ids (which are like array indices). 57 #[inline(always)] get_field_offset(&self, vtable_offset: VOffsetT) -> VOffsetT58 pub fn get_field_offset(&self, vtable_offset: VOffsetT) -> VOffsetT { 59 let idx = vtable_offset as usize; 60 read_scalar_at::<VOffsetT>(&self.buf, idx) 61 } 62 63 /// Writes an object field offset into the vtable. 64 /// 65 /// Note that this expects field offsets (which are like pointers), not 66 /// field ids (which are like array indices). 67 #[inline(always)] write_field_offset(&mut self, vtable_offset: VOffsetT, object_data_offset: VOffsetT)68 pub fn write_field_offset(&mut self, vtable_offset: VOffsetT, object_data_offset: VOffsetT) { 69 let idx = vtable_offset as usize; 70 emplace_scalar::<VOffsetT>(&mut self.buf[idx..idx + SIZE_VOFFSET], object_data_offset); 71 } 72 73 /// Clears all data in this VTableWriter. Used to cleanly undo a 74 /// vtable write. 75 #[inline(always)] clear(&mut self)76 pub fn clear(&mut self) { 77 // This is the closest thing to memset in Rust right now. 78 let len = self.buf.len(); 79 let p = self.buf.as_mut_ptr() as *mut u8; 80 unsafe { 81 write_bytes(p, 0, len); 82 } 83 } 84 } 85