---

yaml
---
r: 140239
b: refs/heads/try2
c: 6210de9
h: refs/heads/master
i:
  140237: f207feb
  140235: 7139566
  140231: a51b9ad
  140223: ce352c7
v: v3

Author: nikomatsakis

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d231c427e655b7164571a1a712563ba5fd2e4a3c
+refs/heads/try2: 6210de9529f37bb4ff51050bca19dfd6f28026c9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/unstable/lang.rs

@@ -19,6 +19,7 @@ use sys;
 use unstable::exchange_alloc;
 use cast::transmute;
 use task::rt::rust_get_task;
+use option::{Some, None};
 
 #[allow(non_camel_case_types)]
 pub type rust_task = c_void;
@@ -71,6 +72,7 @@ pub fn fail_bounds_check(file: *c_char, line: size_t,
     }
 }
 
+#[deriving(Eq)]
 struct BorrowRecord {
     box: *mut BoxRepr,
     file: *c_char,
@@ -108,7 +110,7 @@ pub fn fail_borrowed(box: *mut BoxRepr, file: *c_char, line: size_t) {
                         str::raw::from_c_str(entry.file)
                     };
                     str::push_str(&mut msg, filename);
-                    str::push_str(&mut msg, fmt!(":%u", line as uint));
+                    str::push_str(&mut msg, fmt!(":%u", entry.line as uint));
                     sep = " and at ";
                 }
             }
@@ -208,15 +210,36 @@ fn add_borrow_to_task_list(a: *mut BoxRepr, file: *c_char, line: size_t) {
     }
 }
 
+fn remove_borrow_from_task_list(a: *mut BoxRepr, file: *c_char, line: size_t) {
+    do swap_task_borrow_list |borrow_list| {
+        let mut borrow_list = borrow_list;
+        let br = BorrowRecord {box: a, file: file, line: line};
+        match borrow_list.rposition_elem(&br) {
+            Some(idx) => {
+                borrow_list.remove(idx);
+                borrow_list
+            }
+            None => {
+                let err = fmt!("no borrow found, br=%?, borrow_list=%?",
+                               br, borrow_list);
+                do str::as_buf(err) |msg_p, _| {
+                    fail_(msg_p as *c_char, file, line)
+                }
+            }
+        }
+    }
+}
+
 #[cfg(not(stage0))]
 #[lang="borrow_as_imm"]
 #[inline(always)]
 pub unsafe fn borrow_as_imm(a: *u8, file: *c_char, line: size_t) -> uint {
     let a: *mut BoxRepr = transmute(a);
     let ref_count = (*a).header.ref_count;
 
-    debug_ptr("borrow_as_imm (ptr): ", a);
-    debug_ptr("borrow_as_imm (ref): ", ref_count as *());
+    debug_ptr("borrow_as_imm (ptr) :", a);
+    debug_ptr("              (ref) :", ref_count as *());
+    debug_ptr("              (line): ", line as *());
 
     if (ref_count & MUT_BIT) != 0 {
         fail_borrowed(a, file, line);
@@ -236,7 +259,7 @@ pub unsafe fn borrow_as_mut(a: *u8, file: *c_char, line: size_t) -> uint {
     let a: *mut BoxRepr = transmute(a);
 
     debug_ptr("borrow_as_mut (ptr): ", a);
-    debug_ptr("borrow_as_mut (line): ", line as *());
+    debug_ptr("              (line): ", line as *());
 
     let ref_count = (*a).header.ref_count;
     if (ref_count & (MUT_BIT|FROZEN_BIT)) != 0 {
@@ -265,18 +288,25 @@ pub unsafe fn return_to_mut(a: *u8) {
 #[cfg(not(stage0))]
 #[lang="return_to_mut"]
 #[inline(always)]
-pub unsafe fn return_to_mut(a: *u8, old_ref_count: uint) {
+pub unsafe fn return_to_mut(a: *u8, old_ref_count: uint,
+                            file: *c_char, line: size_t) {
     // Sometimes the box is null, if it is conditionally frozen.
     // See e.g. #4904.
     if !a.is_null() {
         let a: *mut BoxRepr = transmute(a);
+        let ref_count = (*a).header.ref_count;
+        let combined = (ref_count & !ALL_BITS) | (old_ref_count & ALL_BITS);
+        (*a).header.ref_count = combined;
 
-        debug_ptr("return_to_mut (ptr): ", a);
-        debug_ptr("return_to_mut (ref): ", old_ref_count as *());
+        debug_ptr("return_to_mut (ptr) : ", a);
+        debug_ptr("              (line): ", line as *());
+        debug_ptr("              (old) : ", old_ref_count as *());
+        debug_ptr("              (new) : ", ref_count as *());
+        debug_ptr("              (comb): ", combined as *());
 
-        let ref_count = (*a).header.ref_count & !ALL_BITS;
-        let old_bits = old_ref_count & ALL_BITS;
-        (*a).header.ref_count = ref_count | old_bits;
+        if ::rt::env::get().debug_borrows {
+            remove_borrow_from_task_list(a, file, line);
+        }
     }
 }
 

branches/try2/src/librustc/middle/trans/common.rs

@@ -469,7 +469,9 @@ pub fn add_clean_temp_mem(bcx: block, val: ValueRef, t: ty::t) {
 }
 pub fn add_clean_return_to_mut(bcx: block,
                                frozen_val_ref: ValueRef,
-                               bits_val_ref: ValueRef) {
+                               bits_val_ref: ValueRef,
+                               filename_val: ValueRef,
+                               line_val: ValueRef) {
     //! When an `@mut` has been frozen, we have to
     //! call the lang-item `return_to_mut` when the
     //! freeze goes out of scope. We need to pass
@@ -495,7 +497,9 @@ pub fn add_clean_return_to_mut(bcx: block,
                                         build::PointerCast(bcx,
                                                            frozen_val_ref,
                                                            T_ptr(T_ptr(T_i8())))),
-                            build::Load(bcx, bits_val_ref)
+                            build::Load(bcx, bits_val_ref),
+                            filename_val,
+                            line_val
                         ],
                         expr::Ignore
                     )

branches/try2/src/librustc/middle/trans/datum.rs

@@ -578,7 +578,8 @@ pub impl Datum {
                     expr::SaveIn(scratch_bits.val));
 
                 add_clean_return_to_mut(
-                    cleanup_bcx, scratch.val, scratch_bits.val);
+                    cleanup_bcx, scratch.val, scratch_bits.val,
+                    filename, line);
             }
         }