Resolve compilation errors caused by Rust upgrade

yuriks · yuriks · commit c290a1802633 · 2016-07-29T22:12:52.000-07:00
diff --git a/src/common/ring_buffer.rs b/src/common/ring_buffer.rs
@@ -8,7 +8,7 @@ pub struct RingBuffer<'a, T: 'a> {
 }
 
 impl<'a, T: Copy> RingBuffer<'a, T> {
-    pub const fn new(ring: &'a mut [T]) -> RingBuffer<'a, T> {
+    pub fn new(ring: &'a mut [T]) -> RingBuffer<'a, T> {
         RingBuffer {
             head: 0,
             tail: 0,
diff --git a/src/drivers/console.rs b/src/drivers/console.rs
@@ -37,7 +37,7 @@ pub struct Console<'a, U: UART + 'a> {
 }
 
 impl<'a, U: UART> Console<'a, U> {
-    pub const fn new(uart: &'a U, buffer: &'static mut [u8],
+    pub fn new(uart: &'a U, buffer: &'static mut [u8],
                      container: Container<App>) -> Console<'a, U> {
         Console {
             uart: uart,
@@ -169,10 +169,9 @@ impl<'a, U: UART> Client for Console<'a, U> {
                 self.apps.each(|app| {
                     let idx = app.read_idx;
                     app.read_buffer = app.read_buffer.take().map(|mut rb| {
-                        use core::raw::Repr;
                         app.read_callback.as_mut().map(|cb| {
                             let buf = rb.as_mut();
-                            cb.schedule(idx, (buf.repr().data as usize), 0);
+                            cb.schedule(idx, (buf.as_ptr() as usize), 0);
                         });
                         rb
                     });
diff --git a/src/drivers/isl29035.rs b/src/drivers/isl29035.rs
@@ -24,7 +24,7 @@ pub struct Isl29035<'a> {
 }
 
 impl<'a> Isl29035<'a> {
-    pub const fn new(i2c: &'a I2CDevice, buffer: &'static mut [u8])
+    pub fn new(i2c: &'a I2CDevice, buffer: &'static mut [u8])
             -> Isl29035<'a> {
         Isl29035 {
             i2c: i2c,
diff --git a/src/drivers/lib.rs b/src/drivers/lib.rs
@@ -1,6 +1,6 @@
 #![crate_name = "drivers"]
 #![crate_type = "rlib"]
-#![feature(const_fn, raw)]
+#![feature(const_fn)]
 #![no_std]
 
 extern crate common;
diff --git a/src/drivers/nrf51822_serialization.rs b/src/drivers/nrf51822_serialization.rs
@@ -29,7 +29,7 @@ pub struct Nrf51822Serialization<'a, U: UART + 'a> {
 }
 
 impl<'a, U: UART> Nrf51822Serialization<'a, U> {
-    pub const fn new(uart: &'a U, buffer: &'static mut [u8]) -> Nrf51822Serialization<'a, U> {
+    pub fn new(uart: &'a U, buffer: &'static mut [u8]) -> Nrf51822Serialization<'a, U> {
         Nrf51822Serialization {
             uart: uart,
             apps: [TakeCell::empty(), TakeCell::empty()],
diff --git a/src/drivers/timer.rs b/src/drivers/timer.rs
@@ -2,7 +2,6 @@ use core::cell::Cell;
 use process::{AppId, Container, Callback};
 use hil::Driver;
 use hil::alarm::{Alarm, AlarmClient, Frequency};
-use hil::timer::{Timer};
 
 #[derive(Copy, Clone)]
 pub struct TimerData {
diff --git a/src/platform/storm/lib.rs b/src/platform/storm/lib.rs
@@ -13,9 +13,8 @@ extern crate process;
 
 use hil::Controller;
 use hil::spi_master::SpiMaster;
-use hil::gpio::GPIOPin;
 use drivers::virtual_alarm::{MuxAlarm, VirtualMuxAlarm};
-use drivers::virtual_i2c::{MuxI2C, I2CDevice};
+use drivers::virtual_i2c::MuxI2C;
 
 #[macro_use]
 pub mod io;
diff --git a/src/process/container.rs b/src/process/container.rs
@@ -4,7 +4,6 @@ use core::marker::PhantomData;
 use core::mem::size_of;
 use core::ops::{Deref, DerefMut};
 use core::ptr::Unique;
-use core::raw::Repr;
 use process::{self, Error};
 
 pub static mut CONTAINER_COUNTER : usize = 0;
@@ -88,7 +87,7 @@ impl<'a> Allocator<'a> {
             let app_id = self.app_id;
             self.app.alloc(size_of::<T>()).map_or(Err(Error::OutOfMemory),
                 |arr| {
-                    let mut owned = Owned::new(arr.repr().data as *mut T, app_id);
+                    let mut owned = Owned::new(arr.as_mut_ptr() as *mut T, app_id);
                     *owned = data;
                     Ok(owned)
             })
diff --git a/src/process/lib.rs b/src/process/lib.rs
@@ -1,7 +1,7 @@
 #![crate_name = "process"]
 #![crate_type = "rlib"]
 #![no_std]
-#![feature(core_intrinsics,clone_from_slice,raw,unique,nonzero,const_fn)]
+#![feature(core_intrinsics,unique,nonzero,const_fn)]
 
 extern crate common;
 extern crate support;
diff --git a/src/process/mem.rs b/src/process/mem.rs
@@ -1,8 +1,7 @@
-use core::mem;
 use core::marker::PhantomData;
 use core::ops::{Deref,DerefMut};
 use core::ptr::Unique;
-use core::raw::Slice;
+use core::slice;
 use process;
 
 use AppId;
@@ -49,7 +48,7 @@ impl<L, T> Drop for AppPtr<L, T> {
         unsafe {
             let ps = &mut process::PROCS;
             if ps.len() < self.process.idx() {
-                ps[self.process.idx()].as_mut().map(|process| 
+                ps[self.process.idx()].as_mut().map(|process|
                     process.free(self.ptr.get_mut())
                 );
             }
@@ -78,23 +77,13 @@ impl<L, T> AppSlice<L, T> {
 
 impl<L, T> AsRef<[T]> for AppSlice<L, T> {
     fn as_ref(&self) -> &[T] {
-        unsafe {
-            mem::transmute(Slice{
-                data: self.ptr.ptr.get(),
-                len: self.len
-            })
-        }
+        unsafe { slice::from_raw_parts(self.ptr.ptr.get(), self.len) }
     }
 }
 
 impl<L, T> AsMut<[T]> for AppSlice<L, T> {
     fn as_mut(&mut self) -> &mut [T] {
-        unsafe {
-            mem::transmute(Slice{
-                data: self.ptr.ptr.get(),
-                len: self.len
-            })
-        }
+        unsafe { slice::from_raw_parts_mut(self.ptr.ptr.get_mut(), self.len) }
     }
 }
 
diff --git a/src/process/process.rs b/src/process/process.rs
@@ -1,6 +1,5 @@
 use core::intrinsics::{breakpoint, volatile_load, volatile_store};
-use core::{mem,ptr,intrinsics};
-use core::raw::{Repr,Slice};
+use core::{intrinsics, mem, ptr, slice};
 
 use common::{RingBuffer, Queue};
 
@@ -78,13 +77,13 @@ struct LoadInfo {
 
 pub struct Process<'a> {
     /// The process's memory.
-    memory: Slice<u8>,
+    memory: &'static mut [u8],
 
     app_memory_break: *const u8,
     kernel_memory_break: *const u8,
 
     /// Process text segment
-    text: Slice<u8>,
+    text: &'static [u8],
 
     /// The offset in `memory` to use for the process stack.
     cur_stack: *const u8,
@@ -106,7 +105,7 @@ pub unsafe fn load_processes(mut start_addr: *const usize) ->
             let length = *start_addr as isize;
             start_addr = (start_addr as *const u8).offset(length) as *const usize;
 
-            *op = Process::create(prog_start, length);
+            *op = Process::create(prog_start as *mut u8, length);
         } else {
             *op = None;
         }
@@ -115,42 +114,40 @@ pub unsafe fn load_processes(mut start_addr: *const usize) ->
 }
 
 impl<'a> Process<'a> {
-    pub const fn mem_start(&self) -> *const u8 {
-        self.memory.data
+    pub fn mem_start(&self) -> *const u8 {
+        self.memory.as_ptr()
     }
 
     pub fn mem_end(&self) -> *const u8 {
         unsafe {
-            self.memory.data.offset(self.memory.len as isize)
+            self.memory.as_ptr().offset(self.memory.len() as isize)
         }
     }
 
     pub fn memory_regions(&self) -> (usize, usize, usize, usize) {
-        let data_start = self.memory.data as usize;
+        let data_start = self.memory.as_ptr() as usize;
         let data_len = 12;
 
-        let text_start = self.text.data as usize;
-        let text_len = ((32 - self.text.len.leading_zeros()) - 2) as usize;
+        let text_start = self.text.as_ptr() as usize;
+        let text_len = ((32 - self.text.len().leading_zeros()) - 2) as usize;
         (data_start, data_len, text_start, text_len)
     }
 
-    pub unsafe fn create(start_addr: *const usize, length: isize) -> Option<Process<'a>> {
+    pub unsafe fn create(start_addr: *const u8, length: isize) -> Option<Process<'a>> {
         let cur_idx = FREE_MEMORY_IDX;
         if cur_idx <= MEMORIES.len() {
             FREE_MEMORY_IDX += 1;
-            let memory = MEMORIES[cur_idx].repr();
+            let memory = &mut MEMORIES[cur_idx];
 
             let mut kernel_memory_break = {
                 // make room for container pointers
                 let psz = mem::size_of::<*const usize>();
                 let num_ctrs = volatile_load(&container::CONTAINER_COUNTER);
                 let container_ptrs_size = num_ctrs * psz;
-                let res = memory.data.offset((memory.len - container_ptrs_size) as isize);
+                let res = memory.as_mut_ptr().offset((memory.len() - container_ptrs_size) as isize);
                 // set all ptrs to null
-                let opts : &mut [*const usize] = mem::transmute(Slice {
-                    data: res as *mut *const usize,
-                    len: num_ctrs
-                });
+                let opts = slice::from_raw_parts_mut(
+                    res as *mut *const usize, num_ctrs);
                 for opt in opts.iter_mut() {
                     *opt = ptr::null()
                 }
@@ -164,24 +161,22 @@ impl<'a> Process<'a> {
             // Set kernel break to beginning of callback buffer
             kernel_memory_break =
                 kernel_memory_break.offset(-(callback_offset as isize));
-            let callback_buf = mem::transmute(Slice {
-                data: kernel_memory_break as *const Option<Callback>,
-                len: callback_len
-            });
+            let callback_buf = slice::from_raw_parts_mut(
+                kernel_memory_break as *mut Callback, callback_len);
 
             let callbacks = RingBuffer::new(callback_buf);
 
-            let load_result = load(start_addr, memory.data);
+            let load_result = load(start_addr, memory.as_mut_ptr());
 
             let stack_bottom = load_result.app_mem_start.offset(512);
 
             let mut process = Process {
                 memory: memory,
                 app_memory_break: stack_bottom,
                 kernel_memory_break: kernel_memory_break,
-                text: Slice {
-                    data: start_addr.offset(-1) as *const u8,
-                    len: length as usize },
+                text: slice::from_raw_parts(
+                    start_addr.offset(-1) as *const u8,
+                    length as usize),
                 cur_stack: stack_bottom,
                 wait_pc: 0,
                 psr: 0x01000000,
@@ -223,12 +218,9 @@ impl<'a> Process<'a> {
     pub fn in_exposed_bounds(&self, buf_start_addr: *const u8, size: usize)
             -> bool {
 
-        let buf_end_addr = ((buf_start_addr as usize) + size) as *const u8;
-
-        let mem_end =
-            ((self.memory.data as usize) + self.memory.len) as *const u8;
+        let buf_end_addr = unsafe { buf_start_addr.offset(size as isize) };
 
-        buf_start_addr >= self.memory.data && buf_end_addr <= mem_end
+        buf_start_addr >= self.mem_start() && buf_end_addr <= self.mem_end()
     }
 
     pub unsafe fn alloc(&mut self, size: usize) -> Option<&mut [u8]> {
@@ -237,10 +229,7 @@ impl<'a> Process<'a> {
             None
         } else {
             self.kernel_memory_break = new_break;
-            Some(mem::transmute(Slice {
-                data: new_break as *mut u8,
-                len: size
-            }))
+            Some(slice::from_raw_parts_mut(new_break as *mut u8, size))
         }
     }
 
@@ -260,7 +249,7 @@ impl<'a> Process<'a> {
         let ctr_ptr = self.container_for::<T>(container_num);
         if (*ctr_ptr).is_null() {
             self.alloc(mem::size_of::<T>()).map(|root_arr| {
-                let root_ptr = root_arr.repr().data as *mut T;
+                let root_ptr = root_arr.as_mut_ptr() as *mut T;
                 *root_ptr = Default::default();
                 volatile_store(ctr_ptr, root_ptr);
                 root_ptr
@@ -306,10 +295,10 @@ impl<'a> Process<'a> {
 
     /// Context switch to the process.
     pub unsafe fn switch_to(&mut self) {
-        if self.cur_stack < self.memory.data {
+        if self.cur_stack < self.memory.as_ptr() {
             breakpoint();
         }
-        let psp = switch_to_user(self.cur_stack, self.memory.data);
+        let psp = switch_to_user(self.cur_stack, self.memory.as_ptr());
         self.cur_stack = psp;
     }
 
@@ -362,22 +351,20 @@ struct LoadResult {
     app_mem_start: *const u8
 }
 
-unsafe fn load(start_addr: *const usize, mem_base: *const u8) -> LoadResult {
+unsafe fn load(mut start_addr: *const u8, mem_base: *mut u8) -> LoadResult {
     let mut result = LoadResult {
         text_start: start_addr as *const u8,
         text_len: 0,
         init_fn: 0,
         app_mem_start: 0 as *const u8
     };
 
-    let mut start_addr = start_addr as *const u8;
     let load_info : &LoadInfo = mem::transmute(start_addr);
     start_addr = start_addr.offset(mem::size_of::<LoadInfo>() as isize);
 
-    let rel_data : &mut [usize] = mem::transmute(Slice{
-        data: start_addr,
-        len: load_info.rel_data_size / 4
-    });
+    let rel_data : &[usize] = slice::from_raw_parts(
+        start_addr as *const usize,
+        load_info.rel_data_size / 4);
     start_addr = start_addr.offset(load_info.rel_data_size as isize);
 
     // Update text location in self
@@ -391,15 +378,13 @@ unsafe fn load(start_addr: *const usize, mem_base: *const u8) -> LoadResult {
         load_info.bss_end_offset - load_info.bss_start_offset);
 
     // Copy data into Data section
-    let init_data : &[u8] = mem::transmute(Slice{
-        data: (load_info.init_data_loc + start_addr as usize) as *mut u8,
-        len: load_info.init_data_size
-    });
-
-    let target_data : &mut [u8] = mem::transmute(Slice{
-        data: mem_base,
-        len: load_info.init_data_size
-    });
+    let init_data : &[u8] = slice::from_raw_parts(
+        (load_info.init_data_loc + start_addr as usize) as *mut u8,
+        load_info.init_data_size);
+
+    let target_data : &mut [u8] = slice::from_raw_parts_mut(
+        mem_base,
+        load_info.init_data_size);
 
     target_data.clone_from_slice(init_data);
 
diff --git a/src/support/arm.rs b/src/support/arm.rs
@@ -36,18 +36,10 @@ pub unsafe fn atomic<F,R>(f: F) -> R where F: FnOnce() -> R {
     return res;
 }
 
-#[cfg(not(test))]
-#[lang="stack_exhausted"]
-pub extern fn stack_exhausted() {}
-
 #[cfg(not(test))]
 #[lang="eh_personality"]
 pub extern fn eh_personality() {}
 
-#[cfg(not(test))]
-#[lang="begin_unwind"]
-pub extern fn begin_unwind() {}
-
 #[doc(hidden)]
 #[no_mangle]
 pub unsafe extern fn __aeabi_unwind_cpp_pr0() {

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ pub struct RingBuffer<'a, T: 'a> {`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`impl<'a, T: Copy> RingBuffer<'a, T> {`
`11`		`- pub const fn new(ring: &'a mut [T]) -> RingBuffer<'a, T> {`
	`11`	`+ pub fn new(ring: &'a mut [T]) -> RingBuffer<'a, T> {`
`12`	`12`	`RingBuffer {`
`13`	`13`	`head: 0,`
`14`	`14`	`tail: 0,`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ pub struct Isl29035<'a> {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`impl<'a> Isl29035<'a> {`
`27`		`- pub const fn new(i2c: &'a I2CDevice, buffer: &'static mut [u8])`
	`27`	`+ pub fn new(i2c: &'a I2CDevice, buffer: &'static mut [u8])`
`28`	`28`	`-> Isl29035<'a> {`
`29`	`29`	`Isl29035 {`
`30`	`30`	`i2c: i2c,`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ pub struct Nrf51822Serialization<'a, U: UART + 'a> {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`impl<'a, U: UART> Nrf51822Serialization<'a, U> {`
`32`		`- pub const fn new(uart: &'a U, buffer: &'static mut [u8]) -> Nrf51822Serialization<'a, U> {`
	`32`	`+ pub fn new(uart: &'a U, buffer: &'static mut [u8]) -> Nrf51822Serialization<'a, U> {`
`33`	`33`	`Nrf51822Serialization {`
`34`	`34`	`uart: uart,`
`35`	`35`	`apps: [TakeCell::empty(), TakeCell::empty()],`