refactoring Address, supporting add/sub ops

src/compiler/backend/arch/x86_64/asm_backend.rs

@@ -3649,13 +3649,13 @@ pub fn emit_context_with_reloc(vm: &VM,
 
             // get ready to go through from the object start (not mem_start) to the end
             let base = obj_dump.reference_addr;
-            let end  = obj_dump.mem_start.plus(obj_dump.mem_size);
+            let end  = obj_dump.mem_start + obj_dump.mem_size;
             assert!(base.is_aligned_to(POINTER_SIZE));
 
             // offset as cursor
             let mut offset = 0;
             while offset < obj_dump.mem_size {
-                let cur_addr = base.plus(offset);
+                let cur_addr = base + offset;
 
                 if obj_dump.reference_offsets.contains(&offset) {
                     // if this offset is a reference field, we put a relocatable label generated by the GC
@@ -3683,7 +3683,7 @@ pub fn emit_context_with_reloc(vm: &VM,
                     // otherwise this offset is plain data
 
                     // write plain word (as bytes)
-                    let next_word_addr = cur_addr.plus(POINTER_SIZE);
+                    let next_word_addr = cur_addr + POINTER_SIZE;
                     if next_word_addr <= end {
                         write_data_bytes(&mut file, cur_addr, next_word_addr);
                     } else {
@@ -3731,7 +3731,7 @@ fn write_data_bytes(f: &mut File, from: Address, to: Address) {
             let byte = unsafe {cursor.load::<u8>()};
             f.write_fmt(format_args!("0x{:x}", byte)).unwrap();
 
-            cursor = cursor.plus(1);
+            cursor = cursor + 1 as ByteSize;
             if cursor != to {
                 f.write(",".as_bytes()).unwrap();
             }

src/compiler/backend/arch/x86_64/mod.rs

@@ -35,8 +35,9 @@ pub use compiler::backend::x86_64::asm_backend::emit_context;
 pub use compiler::backend::x86_64::asm_backend::emit_context_with_reloc;
 #[cfg(feature = "aot")]
 pub use compiler::backend::x86_64::asm_backend::spill_rewrite;
-use utils::Address;
 
+use utils::Address;
+use utils::ByteSize;
 use ast::ptr::P;
 use ast::ir::*;
 use ast::types::*;
@@ -526,13 +527,13 @@ pub fn get_previous_frame_pointer(frame_pointer: Address) -> Address {
 /// gets the return address for the current frame pointer
 #[inline(always)]
 pub fn get_return_address(frame_pointer: Address) -> Address {
-    unsafe { frame_pointer.plus(8).load::<Address>() }
+    unsafe { (frame_pointer + 8 as ByteSize).load::<Address>() }
 }
 
 /// gets the stack pointer before the current frame was created
 #[inline(always)]
 pub fn get_previous_stack_pointer(frame_pointer: Address) -> Address {
-    frame_pointer.plus(16)
+    frame_pointer + 16 as ByteSize
 }
 
 /// sets the stack point
@@ -544,7 +545,7 @@ pub fn set_previous_frame_pointer(frame_pointer: Address, value: Address) {
 /// gets the return address for the current frame pointer
 #[inline(always)]
 pub fn set_return_address(frame_pointer: Address, value: Address) {
-    unsafe { frame_pointer.plus(8).store::<Address>(value) }
+    unsafe { (frame_pointer + 8 as ByteSize).store::<Address>(value) }
 }
 
 /// returns offset of callee saved register

src/gc/src/common/address_bitmap.rs

@@ -26,7 +26,7 @@ pub struct AddressBitmap {
 
 impl AddressBitmap {
     pub fn new(start: Address, end: Address) -> AddressBitmap {
-        let bitmap_len = end.diff(start) >> LOG_POINTER_SIZE;
+        let bitmap_len = (end - start) >> LOG_POINTER_SIZE;
         let bitmap = Bitmap::new(bitmap_len);
         
         AddressBitmap{start: start, end: end, bitmap: bitmap}
@@ -37,7 +37,7 @@ impl AddressBitmap {
     pub unsafe fn set_bit(&self, addr: Address) {
         use std::mem;
         let mutable_bitmap : &mut Bitmap = mem::transmute(&self.bitmap);
-        mutable_bitmap.set_bit(addr.diff(self.start) >> LOG_POINTER_SIZE);
+        mutable_bitmap.set_bit((addr - self.start) >> LOG_POINTER_SIZE);
     }
     
     #[inline(always)]
@@ -45,17 +45,17 @@ impl AddressBitmap {
     pub unsafe fn clear_bit(&self, addr: Address) {
         use std::mem;
         let mutable_bitmap : &mut Bitmap = mem::transmute(&self.bitmap);        
-        mutable_bitmap.clear_bit(addr.diff(self.start) >> LOG_POINTER_SIZE);
+        mutable_bitmap.clear_bit((addr - self.start) >> LOG_POINTER_SIZE);
     }
     
     #[inline(always)]
     pub fn test_bit(&self, addr: Address) -> bool {
-        self.bitmap.test_bit(addr.diff(self.start) >> LOG_POINTER_SIZE)
+        self.bitmap.test_bit((addr - self.start) >> LOG_POINTER_SIZE)
     }
         
     #[inline(always)]
     pub fn length_until_next_bit(&self, addr: Address) -> usize {
-        self.bitmap.length_until_next_bit(addr.diff(self.start) >> LOG_POINTER_SIZE)
+        self.bitmap.length_until_next_bit((addr - self.start) >> LOG_POINTER_SIZE)
     }
     
     #[inline(always)]
@@ -67,7 +67,7 @@ impl AddressBitmap {
             assert!(addr >= self.start && addr <= self.end);
         }
         
-        let index = addr.diff(self.start) >> LOG_POINTER_SIZE;
+        let index = (addr - self.start) >> LOG_POINTER_SIZE;
         let mutable_bitmap : &mut Bitmap = mem::transmute(&self.bitmap);
         mutable_bitmap.set(index, value, length);
     }
@@ -78,7 +78,7 @@ impl AddressBitmap {
             assert!(addr >= self.start && addr <= self.end);
         }
         
-        let index = addr.diff(self.start) >> LOG_POINTER_SIZE;
+        let index = (addr - self.start) >> LOG_POINTER_SIZE;
         self.bitmap.get(index, length)
     }
 

src/gc/src/common/address_map.rs

@@ -29,7 +29,7 @@ pub struct AddressMap<T: Copy> {
 
 impl <T> AddressMap<T> where T: Copy{
     pub fn new(start: Address, end: Address) -> AddressMap<T> {
-        let len = end.diff(start) >> LOG_POINTER_SIZE;
+        let len = (end - start) >> LOG_POINTER_SIZE;
         let ptr = unsafe{malloc_zero(mem::size_of::<T>() * len)} as *mut T;
         
         AddressMap{start: start, end: end, ptr: ptr, len: len}
@@ -40,19 +40,19 @@ impl <T> AddressMap<T> where T: Copy{
         
         while cursor < self.end {
             self.set(cursor, init);
-            cursor = cursor.plus(POINTER_SIZE);	
+            cursor = cursor + POINTER_SIZE;
         }
     }
     
     #[inline(always)]
     pub fn set(&self, addr: Address, value: T) {
-        let index = (addr.diff(self.start) >> LOG_POINTER_SIZE) as isize;
+        let index = ((addr - self.start) >> LOG_POINTER_SIZE) as isize;
         unsafe{*self.ptr.offset(index) = value};
     }
 
     #[inline(always)]
     pub fn get(&self, addr: Address) -> T {
-        let index = (addr.diff(self.start) >> LOG_POINTER_SIZE) as isize;
+        let index = ((addr - self.start) >> LOG_POINTER_SIZE) as isize;
         unsafe {*self.ptr.offset(index)}
     }
 }

src/gc/src/common/objectdump.rs

@@ -64,7 +64,7 @@ impl HeapDump {
 
     fn persist_object(&self, obj: Address) -> ObjectDump {
         trace!("dump object: {}", obj);
-        let hdr_addr = obj.offset(objectmodel::OBJECT_HEADER_OFFSET);
+        let hdr_addr = obj + objectmodel::OBJECT_HEADER_OFFSET;
         let hdr = unsafe {hdr_addr.load::<u64>()};
 
         if objectmodel::header_is_fix_size(hdr) {
@@ -132,7 +132,7 @@ impl HeapDump {
         let base = obj_dump.reference_addr;
 
         for offset in obj_dump.reference_offsets.iter() {
-            let field_addr = base.plus(*offset);
+            let field_addr = base + *offset;
             let edge = unsafe {field_addr.load::<Address>()};
 
             if !edge.is_zero() && !self.objects.contains_key(&edge) {

src/gc/src/heap/freelist/treadmill.rs

@@ -50,7 +50,7 @@ impl FreeListSpace {
             Err(_) => panic!("failed to call mmap")
         };
         let start : Address = Address::from_ptr::<u8>(anon_mmap.ptr()).align_up(SPACE_ALIGN);
-        let end   : Address = start.plus(space_size);
+        let end   : Address = start + space_size;
 
         let trace_map = AddressMap::new(start, end);
         let alloc_map = AddressMap::new(start, end);
@@ -102,7 +102,7 @@ impl FreeListSpace {
         if res.is_zero() {
             res
         } else {
-            res.offset(-objectmodel::OBJECT_HEADER_OFFSET)
+            res + (-objectmodel::OBJECT_HEADER_OFFSET)
         }
     }
 
@@ -259,7 +259,7 @@ struct Treadmill{
 
 impl Treadmill {
     fn new(start: Address, end: Address) -> Treadmill {
-        let half_space = start.plus(end.diff(start) / 2);
+        let half_space = start + ((end - start) / 2);
 
         let mut from_space = vec![];
         let mut to_space   = vec![];
@@ -268,12 +268,12 @@ impl Treadmill {
 
         while addr < half_space {
             from_space.push(TreadmillNode::new(addr));
-            addr = addr.plus(BLOCK_SIZE);
+            addr = addr + BLOCK_SIZE;
         }
 
         while addr < end {
             to_space.push(TreadmillNode::new(addr));
-            addr = addr.plus(BLOCK_SIZE);
+            addr = addr + BLOCK_SIZE;
         }
 
         Treadmill {
@@ -392,7 +392,7 @@ impl Treadmill {
             // we need to check if 7&8, 8&9 (cursor is 7, and 8)
             let mut cursor = start;
             while cursor < start + n_blocks - 1 {
-                if from_space[cursor].payload.plus(BLOCK_SIZE) != from_space[cursor + 1].payload {
+                if from_space[cursor].payload + BLOCK_SIZE != from_space[cursor + 1].payload {
                     return false;
                 }
 

src/gc/src/heap/gc/mod.rs

@@ -117,7 +117,7 @@ pub fn stack_scan() -> Vec<ObjectReference> {
             ret.push(unsafe {value.to_object_reference()});
         }
         
-        cursor = cursor.plus(POINTER_SIZE);
+        cursor = cursor + POINTER_SIZE;
     }
     
     let roots_from_stack = ret.len();
@@ -473,7 +473,7 @@ pub fn steal_trace_object(obj: ObjectReference, local_queue: &mut Vec<ObjectRefe
     // this part of code has some duplication with code in objectdump
     // FIXME: remove the duplicate code - use 'Tracer' trait
 
-    let hdr = unsafe {addr.offset(objectmodel::OBJECT_HEADER_OFFSET).load::<u64>()};
+    let hdr = unsafe {(addr + objectmodel::OBJECT_HEADER_OFFSET).load::<u64>()};
 
     if objectmodel::header_is_fix_size(hdr) {
         // fix sized type
@@ -589,7 +589,7 @@ pub fn steal_process_edge(base: Address, offset: usize, local_queue:&mut Vec<Obj
 #[inline(always)]
 #[cfg(not(feature = "use-sidemap"))]
 pub fn steal_process_edge(base: Address, offset: usize, local_queue:&mut Vec<ObjectReference>, job_sender: &mpsc::Sender<ObjectReference>, mark_state: u8, immix_space: &ImmixSpace, lo_space: &FreeListSpace) {
-    let field_addr = base.plus(offset);
+    let field_addr = base + offset;
     let edge = unsafe {field_addr.load::<ObjectReference>()};
 
     if cfg!(debug_assertions) {

src/gc/src/heap/immix/immix_mutator.rs

@@ -18,6 +18,7 @@ use heap::immix::immix_space::ImmixBlock;
 use heap::gc;
 use objectmodel;
 use utils::Address;
+use utils::ByteSize;
 
 use std::*;
 use std::sync::Arc;
@@ -161,7 +162,7 @@ impl ImmixMutatorLocal {
         }
 
         let start = self.cursor.align_up(align);
-        let end = start.plus(size);
+        let end = start + size;
 
         if TRACE_ALLOC_FASTPATH {
             trace!("Mutator{}: fastpath alloc: start=0x{:x}, end=0x{:x}", self.id, start, end);
@@ -182,7 +183,7 @@ impl ImmixMutatorLocal {
             }
 
             // this offset should be removed as well (for performance)
-            ret.offset(-objectmodel::OBJECT_HEADER_OFFSET)
+            ret + (-objectmodel::OBJECT_HEADER_OFFSET)
         } else {
             if cfg!(debug_assertions) {
                 if !start.is_aligned_to(align) {
@@ -193,7 +194,7 @@ impl ImmixMutatorLocal {
             }
             self.cursor = end;
             
-            start.offset(-objectmodel::OBJECT_HEADER_OFFSET)
+            start + (-objectmodel::OBJECT_HEADER_OFFSET)
         } 
     }
     
@@ -211,7 +212,7 @@ impl ImmixMutatorLocal {
     #[cfg(not(feature = "use-sidemap"))]
     pub fn init_object(&mut self, addr: Address, encode: u64) {
         unsafe {
-            addr.offset(objectmodel::OBJECT_HEADER_OFFSET).store(encode);
+            (addr + objectmodel::OBJECT_HEADER_OFFSET).store(encode);
         }
     }
 
@@ -225,7 +226,7 @@ impl ImmixMutatorLocal {
     pub fn init_hybrid(&mut self, addr: Address, encode: u64, len: u64) {
         let encode = encode | ((len << objectmodel::SHR_HYBRID_LENGTH) & objectmodel::MASK_HYBRID_LENGTH);
         unsafe {
-            addr.offset(objectmodel::OBJECT_HEADER_OFFSET).store(encode);
+            (addr + objectmodel::OBJECT_HEADER_OFFSET).store(encode);
         }
     }
     
@@ -242,11 +243,11 @@ impl ImmixMutatorLocal {
                     // we can alloc from local blocks
                     let end_line = self.block().get_next_unavailable_line(next_available_line);
 
-                    self.cursor = self.block().start().plus(next_available_line << immix::LOG_BYTES_IN_LINE);
-                    self.limit  = self.block().start().plus(end_line << immix::LOG_BYTES_IN_LINE);
+                    self.cursor = self.block().start() + (next_available_line << immix::LOG_BYTES_IN_LINE);
+                    self.limit  = self.block().start() + (end_line << immix::LOG_BYTES_IN_LINE);
                     self.line   = end_line;
                     
-                    self.cursor.memset(0, self.limit.diff(self.cursor));
+                    unsafe {self.cursor.memset(0, self.limit - self.cursor);}
                     
                     for line in next_available_line..end_line {
                         self.block().line_mark_table_mut().set(line, immix::LineMark::FreshAlloc);
@@ -254,7 +255,7 @@ impl ImmixMutatorLocal {
 
                     // allocate fast path
                     let start = self.cursor.align_up(align);
-                    let end = start.plus(size);
+                    let end = start + size;
 
                     self.cursor = end;
                     start
@@ -344,9 +345,9 @@ impl ImmixMutatorLocal {
     pub fn print_object_static(obj: Address, length: usize) {
         debug!("===Object {:#X} size: {} bytes===", obj, length);
         let mut cur_addr = obj;
-        while cur_addr < obj.plus(length) {
+        while cur_addr < obj + length {
             debug!("Address: {:#X}   {:#X}", cur_addr, unsafe {cur_addr.load::<u64>()});
-            cur_addr = cur_addr.plus(8);
+            cur_addr = cur_addr + 8 as ByteSize;
         }
         debug!("----");
         debug!("=========");        

src/gc/src/heap/immix/immix_space.rs

@@ -45,7 +45,7 @@ pub struct LineMarkTableSlice {
 
 impl LineMarkTable {
     pub fn new(space_start: Address, space_end: Address) -> LineMarkTable {
-        let line_mark_table_len = space_end.diff(space_start) / immix::BYTES_IN_LINE;
+        let line_mark_table_len = (space_end - space_start) / immix::BYTES_IN_LINE;
         let line_mark_table = {
             let ret = unsafe {malloc_zero(mem::size_of::<immix::LineMark>() * line_mark_table_len)} as *mut immix::LineMark;
             let mut cursor = ret;
@@ -79,12 +79,12 @@ impl LineMarkTable {
     }
 
     pub fn index_to_address(&self, index: usize) -> Address {
-        self.space_start.plus(index << immix::LOG_BYTES_IN_LINE)
+        self.space_start + (index << immix::LOG_BYTES_IN_LINE)
     }
     
     #[inline(always)]
     pub fn mark_line_live(&self, addr: Address) {
-        let line_table_index = addr.diff(self.space_start) >> immix::LOG_BYTES_IN_LINE;
+        let line_table_index = (addr - self.space_start) >> immix::LOG_BYTES_IN_LINE;
         
         self.set(line_table_index, immix::LineMark::Live);
         
@@ -95,7 +95,7 @@ impl LineMarkTable {
 
     #[inline(always)]
     pub fn mark_line_live2(&self, space_start: Address, addr: Address) {
-        let line_table_index = addr.diff(space_start) >> immix::LOG_BYTES_IN_LINE;
+        let line_table_index = (addr - space_start) >> immix::LOG_BYTES_IN_LINE;
 
         self.set(line_table_index, immix::LineMark::Live);
 
@@ -165,7 +165,7 @@ impl ImmixSpace {
             Err(_) => panic!("failed to call mmap"),
         };
         let start : Address = Address::from_ptr::<u8>(anon_mmap.ptr()).align_up(SPACE_ALIGN);
-        let end   : Address = start.plus(space_size);
+        let end   : Address = start + space_size;
         
         let line_mark_table = LineMarkTable::new(start, end);
         
@@ -204,7 +204,7 @@ impl ImmixSpace {
         
         let mut usable_blocks_lock = self.usable_blocks.lock().unwrap();
         
-        while block_start.plus(immix::BYTES_IN_BLOCK) <= self.end {
+        while block_start + immix::BYTES_IN_BLOCK <= self.end {
             usable_blocks_lock.push_back(Box::new(ImmixBlock {
                 id : id,
                 state: immix::BlockMark::Usable,
@@ -213,7 +213,7 @@ impl ImmixSpace {
             }));
             
             id += 1;
-            block_start = block_start.plus(immix::BYTES_IN_BLOCK);
+            block_start = block_start + immix::BYTES_IN_BLOCK;
             line += immix::LINES_IN_BLOCK;
         }
         
@@ -372,7 +372,7 @@ impl ImmixBlock {
         let line_mark_table = self.line_mark_table();
         for i in 0..line_mark_table.len {
             if line_mark_table.get(i) == immix::LineMark::Free {
-                let line_start : Address = self.start.plus(i << immix::LOG_BYTES_IN_LINE);
+                let line_start : Address = self.start + (i << immix::LOG_BYTES_IN_LINE);
 
                 // zero the line
                 unsafe {

src/gc/src/heap/mod.rs

@@ -79,7 +79,7 @@ pub trait Space {
         }
 
         // use header
-        let hdr = unsafe {addr.offset(objectmodel::OBJECT_HEADER_OFFSET).load::<u64>()};
+        let hdr = unsafe {(addr + objectmodel::OBJECT_HEADER_OFFSET).load::<u64>()};
         if !objectmodel::header_is_object_start(hdr) {
             return false;
         }
@@ -100,5 +100,5 @@ pub trait Space {
 #[inline(always)]
 pub fn fill_alignment_gap(start : Address, end : Address) -> () {
     debug_assert!(end >= start);
-    start.memset(ALIGNMENT_VALUE, end.diff(start));
+    unsafe {start.memset(ALIGNMENT_VALUE, end - start);}
 }

src/gc/src/objectmodel/header.rs

@@ -120,7 +120,7 @@ pub fn print_object(obj: Address) {
     let mut cursor = obj;
     trace!("OBJECT 0x{:x}", obj);
 
-    let hdr = unsafe {cursor.offset(OBJECT_HEADER_OFFSET).load::<u64>()};
+    let hdr = unsafe {(cursor + OBJECT_HEADER_OFFSET).load::<u64>()};
 
     trace!("- is object start? {}", header_is_object_start(hdr));
     trace!("- is traced? {}", header_is_traced(hdr, objectmodel::load_mark_state()));
@@ -137,23 +137,23 @@ pub fn print_object(obj: Address) {
 
     trace!("0x{:x} | val: 0x{:15x} | hdr: {:b}",
     cursor, unsafe{cursor.load::<u64>()}, hdr);
-    cursor = cursor.plus(POINTER_SIZE);
+    cursor = cursor + POINTER_SIZE;
     trace!("0x{:x} | val: 0x{:15x}",
     cursor, unsafe{cursor.load::<u64>()});
 
-    cursor = cursor.plus(POINTER_SIZE);
+    cursor = cursor + POINTER_SIZE;
     trace!("0x{:x} | val: 0x{:15x}",
     cursor, unsafe{cursor.load::<u64>()});
 
-    cursor = cursor.plus(POINTER_SIZE);
+    cursor = cursor + POINTER_SIZE;
     trace!("0x{:x} | val: 0x{:15x}",
     cursor, unsafe{cursor.load::<u64>()});
 
-    cursor = cursor.plus(POINTER_SIZE);
+    cursor = cursor + POINTER_SIZE;
     trace!("0x{:x} | val: 0x{:15x}",
     cursor, unsafe{cursor.load::<u64>()});
 
-    cursor = cursor.plus(POINTER_SIZE);
+    cursor = cursor + POINTER_SIZE;
     trace!("0x{:x} | val: 0x{:15x}",
     cursor, unsafe{cursor.load::<u64>()});
 }
@@ -161,7 +161,7 @@ pub fn print_object(obj: Address) {
 #[inline(always)]
 pub fn mark_as_traced(obj: ObjectReference, mark_state: u8) {
     unsafe {
-        let hdr_addr = obj.to_address().offset(OBJECT_HEADER_OFFSET);
+        let hdr_addr = obj.to_address() + OBJECT_HEADER_OFFSET;
         hdr_addr.store(bit_utils::set_nth_bit_u64(hdr_addr.load::<u64>(), BIT_IS_TRACED, mark_state));
     }
 }
@@ -169,7 +169,7 @@ pub fn mark_as_traced(obj: ObjectReference, mark_state: u8) {
 #[inline(always)]
 pub fn mark_as_untraced(addr: Address, mark_state: u8) {
     unsafe {
-        let hdr_addr = addr.offset(OBJECT_HEADER_OFFSET);
+        let hdr_addr = addr + OBJECT_HEADER_OFFSET;
         hdr_addr.store(bit_utils::set_nth_bit_u64(hdr_addr.load::<u64>(), BIT_IS_TRACED, mark_state ^ 1));
     }
 }
@@ -177,7 +177,7 @@ pub fn mark_as_untraced(addr: Address, mark_state: u8) {
 #[inline(always)]
 pub fn is_traced(obj: ObjectReference, mark_state: u8) -> bool {
     unsafe {
-        let hdr = obj.to_address().offset(OBJECT_HEADER_OFFSET).load::<u64>();
+        let hdr = (obj.to_address() + OBJECT_HEADER_OFFSET).load::<u64>();
         bit_utils::test_nth_bit_u64(hdr, BIT_IS_TRACED, mark_state)
     }
 }

src/runtime/exception.rs

@@ -102,8 +102,8 @@ pub extern fn throw_exception_internal(exception_obj: Address, frame_cursor: Add
             let ref callee_saved = cf.frame.callee_saved;
             for (target_offset, source_offset) in callee_saved {
                 // *(frame_cursor + target_offset) = *(frame_pointer + source_offset)
-                let val = previous_frame_pointer.offset(*source_offset).load::<Address>();
-                frame_cursor.offset(*target_offset).store::<Address>(val);
+                let val = (previous_frame_pointer + *source_offset).load::<Address>();
+                (frame_cursor + *target_offset).store::<Address>(val);
             }
         }
 
@@ -124,7 +124,7 @@ fn print_frame(cursor: Address) {
     let bottom = -(CALLEE_SAVED_COUNT as isize);
     for i in (bottom .. top).rev() {
         unsafe {
-            let addr = cursor.offset(i * POINTER_SIZE as isize);
+            let addr = cursor + (i * POINTER_SIZE as isize);
             let val  = addr.load::<Word>();
             trace!("\taddr: 0x{:x} | val: 0x{:x} {}", addr, val, {if addr == cursor {"<- cursor"} else {""}});
         }

src/runtime/thread.rs

@@ -118,8 +118,8 @@ impl MuStack {
 
         // calculate the addresses
         let overflow_guard = mmap_start;
-        let lower_bound = mmap_start.plus(PAGE_SIZE);
-        let upper_bound = lower_bound.plus(STACK_SIZE);
+        let lower_bound = mmap_start + PAGE_SIZE;
+        let upper_bound = lower_bound + STACK_SIZE;
         let underflow_guard = upper_bound;
 
         // protect the guard pages
@@ -185,7 +185,7 @@ impl MuStack {
         // store floating point argument registers
         let mut stack_ptr = self.sp;
         for i in 0..ARGUMENT_FPRS.len() {
-            stack_ptr = stack_ptr.sub(WORD_SIZE);
+            stack_ptr -= WORD_SIZE;
             let val = {
                 if i < fpr_used.len() {
                     fpr_used[i]
@@ -200,7 +200,7 @@ impl MuStack {
 
         // store general purpose argument registers
         for i in 0..ARGUMENT_GPRS.len() {
-            stack_ptr = stack_ptr.sub(WORD_SIZE);
+            stack_ptr -= WORD_SIZE;
             let val = {
                 if i < gpr_used.len() {
                     gpr_used[i]
@@ -227,7 +227,7 @@ impl MuStack {
         use utils::Word;
         use utils::WORD_SIZE;
         
-        let mut cursor = self.upper_bound.sub(WORD_SIZE);
+        let mut cursor = self.upper_bound - WORD_SIZE;
         let mut count = 0;
         
         debug!("0x{:x} | UPPER_BOUND", self.upper_bound);
@@ -240,7 +240,7 @@ impl MuStack {
                 debug!("0x{:x} | 0x{:x} ({})", cursor, val, val);
             }
             
-            cursor = cursor.sub(WORD_SIZE);
+            cursor -= WORD_SIZE;
             count += 1;
             
             if n_entries.is_some() && count > n_entries.unwrap() {
@@ -382,7 +382,7 @@ impl MuThread {
             unsafe {set_thread_local(muthread)};
 
             let addr = unsafe {muentry_get_thread_local()};
-            let sp_threadlocal_loc = addr.plus(*NATIVE_SP_LOC_OFFSET);
+            let sp_threadlocal_loc = addr + *NATIVE_SP_LOC_OFFSET;
             debug!("new sp: 0x{:x}", new_sp);
             debug!("sp_store: 0x{:x}", sp_threadlocal_loc);
 

src/utils/src/address.rs

@@ -15,110 +15,188 @@
 use std::cmp;
 use std::fmt;
 use std::mem;
+use std::sync::atomic::{AtomicPtr, Ordering};
+use std::ops::*;
+
+use {ByteOffset, ByteSize};
 
 /// Address represents an arbitrary address. This is designed to represent
 /// address and do address arithmetic mostly in a safe way, and to allow
 /// mark some operations as unsafe. This type needs to be zero overhead
-/// (memory wise and time wise).
-/// The idea is from the paper High-level Low-level Programming (VEE09),
-/// and JikesRVM. 
+/// (memory wise and time wise). The idea is from the paper
+/// High-level Low-level Programming (VEE09) and JikesRVM.
 #[repr(C)]
 #[derive(Copy, Clone, Eq, Hash)]
 pub struct Address(usize);
 
+/// Address + ByteSize (positive)
+impl Add<ByteSize> for Address {
+    type Output = Address;
+    fn add(self, offset: ByteSize) -> Address {
+        Address(self.0 + offset)
+    }
+}
+/// Address += ByteSize (positive)
+impl AddAssign<ByteSize> for Address {
+    fn add_assign(&mut self, offset: ByteSize) {
+        self.0 += offset;
+    }
+}