diff --git a/Makefile.in b/Makefile.in index 5d4760136124a..7f1a6945d8a35 100644 --- a/Makefile.in +++ b/Makefile.in @@ -124,11 +124,6 @@ endif ifdef TRACE CFG_RUSTC_FLAGS += -Z trace endif -ifndef DEBUG_BORROWS - RUSTFLAGS_STAGE0 += -Z no-debug-borrows - RUSTFLAGS_STAGE1 += -Z no-debug-borrows - RUSTFLAGS_STAGE2 += -Z no-debug-borrows -endif # The executables crated during this compilation process have no need to include # static copies of libstd and libextra. We also generate dynamic versions of all diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 101b2e36bd6c1..06c13c7de15ac 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -126,7 +126,7 @@ pub mod write { session::Default => lib::llvm::CodeGenLevelDefault, session::Aggressive => lib::llvm::CodeGenLevelAggressive, }; - let use_softfp = sess.opts.debugging_opts & session::use_softfp != 0; + let use_softfp = sess.opts.debugging_opts & session::USE_SOFTFP != 0; let tm = sess.targ_cfg.target_strs.target_triple.with_c_str(|T| { sess.opts.target_cpu.with_c_str(|CPU| { @@ -156,7 +156,6 @@ pub mod write { pass.with_c_str(|s| llvm::LLVMRustAddPass(fpm, s)) }; if !sess.no_verify() { assert!(addpass("verify")); } - if sess.lint_llvm() { assert!(addpass("lint")); } if !sess.no_prepopulate_passes() { llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod); @@ -988,7 +987,7 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path, let mut cc_args = sess.targ_cfg.target_strs.cc_args.clone(); cc_args.push_all_move(link_args(sess, dylib, tmpdir.path(), obj_filename, out_filename)); - if (sess.opts.debugging_opts & session::print_link_args) != 0 { + if (sess.opts.debugging_opts & session::PRINT_LINK_ARGS) != 0 { println!("{} link args: '{}'", cc_prog, cc_args.connect("' '")); } diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 9555a706f0874..dcab4376cd1d7 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -759,22 +759,22 @@ pub fn build_session_options(binary: ~str, } } - let mut debugging_opts = 0u; + let mut debugging_opts = 0; let debug_flags = matches.opt_strs("Z"); let debug_map = session::debugging_opts_map(); for debug_flag in debug_flags.iter() { - let mut this_bit = 0u; + let mut this_bit = 0; for tuple in debug_map.iter() { let (name, bit) = match *tuple { (ref a, _, b) => (a, b) }; if *name == *debug_flag { this_bit = bit; break; } } - if this_bit == 0u { + if this_bit == 0 { early_error(demitter, format!("unknown debug flag: {}", *debug_flag)) } debugging_opts |= this_bit; } - if debugging_opts & session::debug_llvm != 0 { + if debugging_opts & session::DEBUG_LLVM != 0 { unsafe { llvm::LLVMSetDebug(1); } } @@ -797,7 +797,7 @@ pub fn build_session_options(binary: ~str, let target_feature = matches.opt_str("target-feature").unwrap_or(~""); let save_temps = matches.opt_present("save-temps"); let opt_level = { - if (debugging_opts & session::no_opt) != 0 { + if (debugging_opts & session::NO_OPT) != 0 { No } else if matches.opt_present("O") { if matches.opt_present("opt-level") { @@ -816,9 +816,9 @@ pub fn build_session_options(binary: ~str, } } else { No } }; - let gc = debugging_opts & session::gc != 0; - let extra_debuginfo = debugging_opts & session::extra_debug_info != 0; - let debuginfo = debugging_opts & session::debug_info != 0 || + let gc = debugging_opts & session::GC != 0; + let extra_debuginfo = debugging_opts & session::EXTRA_DEBUG_INFO != 0; + let debuginfo = debugging_opts & session::DEBUG_INFO != 0 || extra_debuginfo; let addl_lib_search_paths = matches.opt_strs("L").map(|s| { diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index ebd6c06e2433c..75094bc808432 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -39,89 +39,91 @@ pub struct Config { uint_type: UintTy, } -pub static verbose: uint = 1 << 0; -pub static time_passes: uint = 1 << 1; -pub static count_llvm_insns: uint = 1 << 2; -pub static time_llvm_passes: uint = 1 << 3; -pub static trans_stats: uint = 1 << 4; -pub static asm_comments: uint = 1 << 5; -pub static no_verify: uint = 1 << 6; -pub static borrowck_stats: uint = 1 << 7; -pub static borrowck_note_pure: uint = 1 << 8; -pub static borrowck_note_loan: uint = 1 << 9; -pub static no_landing_pads: uint = 1 << 10; -pub static debug_llvm: uint = 1 << 11; -pub static count_type_sizes: uint = 1 << 12; -pub static meta_stats: uint = 1 << 13; -pub static no_opt: uint = 1 << 14; -pub static gc: uint = 1 << 15; -pub static debug_info: uint = 1 << 16; -pub static extra_debug_info: uint = 1 << 17; -pub static print_link_args: uint = 1 << 18; -pub static no_debug_borrows: uint = 1 << 19; -pub static lint_llvm: uint = 1 << 20; -pub static print_llvm_passes: uint = 1 << 21; -pub static no_vectorize_loops: uint = 1 << 22; -pub static no_vectorize_slp: uint = 1 << 23; -pub static no_prepopulate_passes: uint = 1 << 24; -pub static use_softfp: uint = 1 << 25; -pub static gen_crate_map: uint = 1 << 26; -pub static prefer_dynamic: uint = 1 << 27; -pub static no_integrated_as: uint = 1 << 28; -pub static lto: uint = 1 << 29; +macro_rules! debugging_opts( + ([ $opt:ident ] $cnt:expr ) => ( + pub static $opt: u64 = 1 << $cnt; + ); + ([ $opt:ident, $($rest:ident),* ] $cnt:expr ) => ( + pub static $opt: u64 = 1 << $cnt; + debugging_opts!([ $($rest),* ] $cnt + 1) + ) +) -pub fn debugging_opts_map() -> ~[(&'static str, &'static str, uint)] { - ~[("verbose", "in general, enable more debug printouts", verbose), - ("time-passes", "measure time of each rustc pass", time_passes), +debugging_opts!( + [ + VERBOSE, + TIME_PASSES, + COUNT_LLVM_INSNS, + TIME_LLVM_PASSES, + TRANS_STATS, + ASM_COMMENTS, + NO_VERIFY, + BORROWCK_STATS, + NO_LANDING_PADS, + DEBUG_LLVM, + COUNT_TYPE_SIZES, + META_STATS, + NO_OPT, + GC, + DEBUG_INFO, + EXTRA_DEBUG_INFO, + PRINT_LINK_ARGS, + PRINT_LLVM_PASSES, + NO_VECTORIZE_LOOPS, + NO_VECTORIZE_SLP, + NO_PREPOPULATE_PASSES, + USE_SOFTFP, + GEN_CRATE_MAP, + PREFER_DYNAMIC, + NO_INTEGRATED_AS, + LTO + ] + 0 +) + +pub fn debugging_opts_map() -> ~[(&'static str, &'static str, u64)] { + ~[("verbose", "in general, enable more debug printouts", VERBOSE), + ("time-passes", "measure time of each rustc pass", TIME_PASSES), ("count-llvm-insns", "count where LLVM \ - instrs originate", count_llvm_insns), + instrs originate", COUNT_LLVM_INSNS), ("time-llvm-passes", "measure time of each LLVM pass", - time_llvm_passes), - ("trans-stats", "gather trans statistics", trans_stats), - ("asm-comments", "generate comments into the assembly (may change behavior)", asm_comments), - ("no-verify", "skip LLVM verification", no_verify), - ("borrowck-stats", "gather borrowck statistics", borrowck_stats), - ("borrowck-note-pure", "note where purity is req'd", - borrowck_note_pure), - ("borrowck-note-loan", "note where loans are req'd", - borrowck_note_loan), + TIME_LLVM_PASSES), + ("trans-stats", "gather trans statistics", TRANS_STATS), + ("asm-comments", "generate comments into the assembly (may change behavior)", + ASM_COMMENTS), + ("no-verify", "skip LLVM verification", NO_VERIFY), + ("borrowck-stats", "gather borrowck statistics", BORROWCK_STATS), ("no-landing-pads", "omit landing pads for unwinding", - no_landing_pads), - ("debug-llvm", "enable debug output from LLVM", debug_llvm), + NO_LANDING_PADS), + ("debug-llvm", "enable debug output from LLVM", DEBUG_LLVM), ("count-type-sizes", "count the sizes of aggregate types", - count_type_sizes), - ("meta-stats", "gather metadata statistics", meta_stats), - ("no-opt", "do not optimize, even if -O is passed", no_opt), - ("print-link-args", "Print the arguments passed to the linker", print_link_args), - ("gc", "Garbage collect shared data (experimental)", gc), + COUNT_TYPE_SIZES), + ("meta-stats", "gather metadata statistics", META_STATS), + ("no-opt", "do not optimize, even if -O is passed", NO_OPT), + ("print-link-args", "Print the arguments passed to the linker", + PRINT_LINK_ARGS), + ("gc", "Garbage collect shared data (experimental)", GC), ("extra-debug-info", "Extra debugging info (experimental)", - extra_debug_info), - ("debug-info", "Produce debug info (experimental)", debug_info), - ("no-debug-borrows", - "do not show where borrow checks fail", - no_debug_borrows), - ("lint-llvm", - "Run the LLVM lint pass on the pre-optimization IR", - lint_llvm), + EXTRA_DEBUG_INFO), + ("debug-info", "Produce debug info (experimental)", DEBUG_INFO), ("print-llvm-passes", "Prints the llvm optimization passes being run", - print_llvm_passes), + PRINT_LLVM_PASSES), ("no-prepopulate-passes", "Don't pre-populate the pass managers with a list of passes, only use \ the passes from --passes", - no_prepopulate_passes), + NO_PREPOPULATE_PASSES), ("no-vectorize-loops", "Don't run the loop vectorization optimization passes", - no_vectorize_loops), - ("no-vectorize-slp", - "Don't run LLVM's SLP vectorization passes", - no_vectorize_slp), - ("soft-float", "Generate software floating point library calls", use_softfp), - ("gen-crate-map", "Force generation of a toplevel crate map", gen_crate_map), - ("prefer-dynamic", "Prefer dynamic linking to static linking", prefer_dynamic), + NO_VECTORIZE_LOOPS), + ("no-vectorize-slp", "Don't run LLVM's SLP vectorization passes", + NO_VECTORIZE_SLP), + ("soft-float", "Generate software floating point library calls", USE_SOFTFP), + ("gen-crate-map", "Force generation of a toplevel crate map", GEN_CRATE_MAP), + ("prefer-dynamic", "Prefer dynamic linking to static linking", PREFER_DYNAMIC), ("no-integrated-as", - "Use external assembler rather than LLVM's integrated one", no_integrated_as), - ("lto", "Perform LLVM link-time optimizations", lto), + "Use external assembler rather than LLVM's integrated one", NO_INTEGRATED_AS), + ("lto", "Perform LLVM link-time optimizations", LTO), ] } @@ -168,7 +170,7 @@ pub struct Options { parse_only: bool, no_trans: bool, no_analysis: bool, - debugging_opts: uint, + debugging_opts: u64, android_cross_path: Option<~str>, /// Whether to write dependency files. It's (enabled, optional filename). write_dependency_info: (bool, Option), @@ -291,66 +293,56 @@ impl Session_ { pub fn diagnostic(&self) -> @diagnostic::SpanHandler { self.span_diagnostic } - pub fn debugging_opt(&self, opt: uint) -> bool { - (self.opts.debugging_opts & opt) != 0u + pub fn debugging_opt(&self, opt: u64) -> bool { + (self.opts.debugging_opts & opt) != 0 } // This exists to help with refactoring to eliminate impossible // cases later on pub fn impossible_case(&self, sp: Span, msg: &str) -> ! { self.span_bug(sp, format!("Impossible case reached: {}", msg)); } - pub fn verbose(&self) -> bool { self.debugging_opt(verbose) } - pub fn time_passes(&self) -> bool { self.debugging_opt(time_passes) } + pub fn verbose(&self) -> bool { self.debugging_opt(VERBOSE) } + pub fn time_passes(&self) -> bool { self.debugging_opt(TIME_PASSES) } pub fn count_llvm_insns(&self) -> bool { - self.debugging_opt(count_llvm_insns) + self.debugging_opt(COUNT_LLVM_INSNS) } pub fn count_type_sizes(&self) -> bool { - self.debugging_opt(count_type_sizes) + self.debugging_opt(COUNT_TYPE_SIZES) } pub fn time_llvm_passes(&self) -> bool { - self.debugging_opt(time_llvm_passes) - } - pub fn trans_stats(&self) -> bool { self.debugging_opt(trans_stats) } - pub fn meta_stats(&self) -> bool { self.debugging_opt(meta_stats) } - pub fn asm_comments(&self) -> bool { self.debugging_opt(asm_comments) } - pub fn no_verify(&self) -> bool { self.debugging_opt(no_verify) } - pub fn lint_llvm(&self) -> bool { self.debugging_opt(lint_llvm) } - pub fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) } - pub fn borrowck_note_pure(&self) -> bool { - self.debugging_opt(borrowck_note_pure) - } - pub fn borrowck_note_loan(&self) -> bool { - self.debugging_opt(borrowck_note_loan) - } - pub fn debug_borrows(&self) -> bool { - self.opts.optimize == No && !self.debugging_opt(no_debug_borrows) + self.debugging_opt(TIME_LLVM_PASSES) } + pub fn trans_stats(&self) -> bool { self.debugging_opt(TRANS_STATS) } + pub fn meta_stats(&self) -> bool { self.debugging_opt(META_STATS) } + pub fn asm_comments(&self) -> bool { self.debugging_opt(ASM_COMMENTS) } + pub fn no_verify(&self) -> bool { self.debugging_opt(NO_VERIFY) } + pub fn borrowck_stats(&self) -> bool { self.debugging_opt(BORROWCK_STATS) } pub fn print_llvm_passes(&self) -> bool { - self.debugging_opt(print_llvm_passes) + self.debugging_opt(PRINT_LLVM_PASSES) } pub fn no_prepopulate_passes(&self) -> bool { - self.debugging_opt(no_prepopulate_passes) + self.debugging_opt(NO_PREPOPULATE_PASSES) } pub fn no_vectorize_loops(&self) -> bool { - self.debugging_opt(no_vectorize_loops) + self.debugging_opt(NO_VECTORIZE_LOOPS) } pub fn no_vectorize_slp(&self) -> bool { - self.debugging_opt(no_vectorize_slp) + self.debugging_opt(NO_VECTORIZE_SLP) } pub fn gen_crate_map(&self) -> bool { - self.debugging_opt(gen_crate_map) + self.debugging_opt(GEN_CRATE_MAP) } pub fn prefer_dynamic(&self) -> bool { - self.debugging_opt(prefer_dynamic) + self.debugging_opt(PREFER_DYNAMIC) } pub fn no_integrated_as(&self) -> bool { - self.debugging_opt(no_integrated_as) + self.debugging_opt(NO_INTEGRATED_AS) } pub fn lto(&self) -> bool { - self.debugging_opt(lto) + self.debugging_opt(LTO) } pub fn no_landing_pads(&self) -> bool { - self.debugging_opt(no_landing_pads) + self.debugging_opt(NO_LANDING_PADS) } // pointless function, now... @@ -396,7 +388,7 @@ pub fn basic_options() -> @Options { parse_only: false, no_trans: false, no_analysis: false, - debugging_opts: 0u, + debugging_opts: 0, android_cross_path: None, write_dependency_info: (false, None), print_metas: (false, false, false), diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 53a1e5697ef34..4d8df829a9448 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -104,7 +104,7 @@ fn runtest(test: &str, cratename: &str, libs: HashSet) { maybe_sysroot: Some(@os::self_exe_path().unwrap().dir_path()), addl_lib_search_paths: @RefCell::new(libs), outputs: ~[session::OutputExecutable], - debugging_opts: session::prefer_dynamic, + debugging_opts: session::PREFER_DYNAMIC, .. (*session::basic_options()).clone() }; diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs deleted file mode 100644 index 7dcbae995ed7b..0000000000000 --- a/src/libstd/rt/borrowck.rs +++ /dev/null @@ -1,220 +0,0 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use c_str::{ToCStr, CString}; -use container::Container; -use iter::Iterator; -use libc::{c_char, size_t}; -use option::{Option, None, Some}; -use ptr::RawPtr; -use rt; -use rt::local::Local; -use rt::task::Task; -use str::OwnedStr; -use str; -use uint; -use unstable::raw; -use vec::{ImmutableVector, OwnedVector}; - -pub static FROZEN_BIT: uint = 1 << (uint::bits - 1); -pub static MUT_BIT: uint = 1 << (uint::bits - 2); -static ALL_BITS: uint = FROZEN_BIT | MUT_BIT; - -#[deriving(Eq)] -pub struct BorrowRecord { - priv alloc: *mut raw::Box<()>, - file: *c_char, - priv line: size_t -} - -fn try_take_task_borrow_list() -> Option<~[BorrowRecord]> { - let mut task = Local::borrow(None::); - task.get().borrow_list.take() -} - -fn swap_task_borrow_list(f: |~[BorrowRecord]| -> ~[BorrowRecord]) { - let borrows = match try_take_task_borrow_list() { - Some(l) => l, - None => ~[] - }; - let borrows = f(borrows); - - let mut task = Local::borrow(None::); - task.get().borrow_list = Some(borrows) -} - -pub fn clear_task_borrow_list() { - // pub because it is used by the box annihilator. - let _ = try_take_task_borrow_list(); -} - -#[cold] -unsafe fn fail_borrowed(alloc: *mut raw::Box<()>, file: *c_char, line: size_t) - -> ! { - debug_borrow("fail_borrowed: ", alloc, 0, 0, file, line); - - match try_take_task_borrow_list() { - None => { // not recording borrows - let msg = "borrowed"; - msg.with_c_str(|msg_p| rt::begin_unwind_raw(msg_p, file, line)) - } - Some(borrow_list) => { // recording borrows - let mut msg = ~"borrowed"; - let mut sep = " at "; - for entry in borrow_list.rev_iter() { - if entry.alloc == alloc { - msg.push_str(sep); - let filename = str::raw::from_c_str(entry.file); - msg.push_str(filename); - msg.push_str(format!(":{}", entry.line)); - sep = " and at "; - } - } - msg.with_c_str(|msg_p| rt::begin_unwind_raw(msg_p, file, line)) - } - } -} - -/// Because this code is so perf. sensitive, use a static constant so that -/// debug printouts are compiled out most of the time. -static ENABLE_DEBUG: bool = false; - -#[inline] -unsafe fn debug_borrow>(tag: &'static str, - p: P, - old_bits: uint, - new_bits: uint, - filename: *c_char, - line: size_t) { - //! A useful debugging function that prints a pointer + tag + newline - //! without allocating memory. - - if ENABLE_DEBUG && rt::env::debug_borrow() { - debug_borrow_slow(tag, p, old_bits, new_bits, filename, line); - } - - unsafe fn debug_borrow_slow>(tag: &'static str, - p: P, - old_bits: uint, - new_bits: uint, - filename: *c_char, - line: size_t) { - let filename = CString::new(filename, false); - rterrln!("{}{:#x} {:x} {:x} {}:{}", - tag, p.to_uint(), old_bits, new_bits, - filename.as_str().unwrap(), line); - } -} - -#[inline] -pub unsafe fn borrow_as_imm(a: *u8, file: *c_char, line: size_t) -> uint { - let a = a as *mut raw::Box<()>; - let old_ref_count = (*a).ref_count; - let new_ref_count = old_ref_count | FROZEN_BIT; - - debug_borrow("borrow_as_imm:", a, old_ref_count, new_ref_count, file, line); - - if (old_ref_count & MUT_BIT) != 0 { - fail_borrowed(a, file, line); - } - - (*a).ref_count = new_ref_count; - - old_ref_count -} - -#[inline] -pub unsafe fn borrow_as_mut(a: *u8, file: *c_char, line: size_t) -> uint { - let a = a as *mut raw::Box<()>; - let old_ref_count = (*a).ref_count; - let new_ref_count = old_ref_count | MUT_BIT | FROZEN_BIT; - - debug_borrow("borrow_as_mut:", a, old_ref_count, new_ref_count, file, line); - - if (old_ref_count & (MUT_BIT|FROZEN_BIT)) != 0 { - fail_borrowed(a, file, line); - } - - (*a).ref_count = new_ref_count; - - old_ref_count -} - -pub unsafe fn record_borrow(a: *u8, old_ref_count: uint, - file: *c_char, line: size_t) { - if (old_ref_count & ALL_BITS) == 0 { - // was not borrowed before - let a = a as *mut raw::Box<()>; - debug_borrow("record_borrow:", a, old_ref_count, 0, file, line); - swap_task_borrow_list(|borrow_list| { - let mut borrow_list = borrow_list; - borrow_list.push(BorrowRecord { - alloc: a, - file: file, - line: line, - }); - borrow_list - }) - } -} - -pub unsafe fn unrecord_borrow(a: *u8, - old_ref_count: uint, - file: *c_char, - line: size_t) { - if (old_ref_count & ALL_BITS) == 0 { - // was not borrowed before, so we should find the record at - // the end of the list - let a = a as *mut raw::Box<()>; - debug_borrow("unrecord_borrow:", a, old_ref_count, 0, file, line); - swap_task_borrow_list(|borrow_list| { - let mut borrow_list = borrow_list; - assert!(!borrow_list.is_empty()); - let br = borrow_list.pop(); - if br.alloc != a || br.file != file || br.line != line { - let err = format!("wrong borrow found, br={:?}", br); - err.with_c_str(|msg_p| { - rt::begin_unwind_raw(msg_p, file, line) - }) - } - borrow_list - }) - } -} - -#[inline] -pub unsafe fn return_to_mut(a: *u8, orig_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 = a as *mut raw::Box<()>; - let old_ref_count = (*a).ref_count; - let new_ref_count = - (old_ref_count & !ALL_BITS) | (orig_ref_count & ALL_BITS); - - debug_borrow("return_to_mut:", - a, old_ref_count, new_ref_count, file, line); - - (*a).ref_count = new_ref_count; - } -} - -#[inline] -pub unsafe fn check_not_borrowed(a: *u8, - file: *c_char, - line: size_t) { - let a = a as *mut raw::Box<()>; - let ref_count = (*a).ref_count; - debug_borrow("check_not_borrowed:", a, ref_count, 0, file, line); - if (ref_count & FROZEN_BIT) != 0 { - fail_borrowed(a, file, line); - } -} diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index e7adb5ad7ddaf..40e9a3ec5b2f3 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -127,9 +127,6 @@ mod util; // Global command line argument storage pub mod args; -// Support for dynamic borrowck -pub mod borrowck; - /// The default error code of the rust runtime if the main task fails instead /// of exiting cleanly. pub static DEFAULT_ERROR_CODE: int = 101; diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 5041c4b616568..e63208bcaec6f 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -27,8 +27,6 @@ use option::{Option, Some, None}; use prelude::drop; use result::{Result, Ok, Err}; use rt::Runtime; -use rt::borrowck::BorrowRecord; -use rt::borrowck; use rt::local::Local; use rt::local_heap::LocalHeap; use rt::rtio::LocalIo; @@ -52,8 +50,6 @@ pub struct Task { death: Death, destroyed: bool, name: Option, - // Dynamic borrowck debugging info - borrow_list: Option<~[BorrowRecord]>, logger: Option<~Logger>, stdout: Option<~Writer>, @@ -93,7 +89,6 @@ impl Task { death: Death::new(), destroyed: false, name: None, - borrow_list: None, logger: None, stdout: None, stderr: None, @@ -182,9 +177,6 @@ impl Task { unsafe { (*handle).unwinder.try(try_block); } - // Cleanup the dynamic borrowck debugging info - borrowck::clear_task_borrow_list(); - // Here we must unsafely borrow the task in order to not remove it from // TLS. When collecting failure, we may attempt to send on a channel (or // just run aribitrary code), so we must be sure to still have a local diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs index 38c713ad7b7d7..8460152ff7bae 100644 --- a/src/libstd/unstable/lang.rs +++ b/src/libstd/unstable/lang.rs @@ -12,7 +12,6 @@ use c_str::ToCStr; use libc::{c_char, size_t, uintptr_t}; -use rt::borrowck; #[cold] #[lang="fail_"] @@ -42,42 +41,3 @@ pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char { pub unsafe fn local_free(ptr: *c_char) { ::rt::local_heap::local_free(ptr); } - -#[lang="borrow_as_imm"] -#[inline] -pub unsafe fn borrow_as_imm(a: *u8, file: *c_char, line: size_t) -> uint { - borrowck::borrow_as_imm(a, file, line) -} - -#[lang="borrow_as_mut"] -#[inline] -pub unsafe fn borrow_as_mut(a: *u8, file: *c_char, line: size_t) -> uint { - borrowck::borrow_as_mut(a, file, line) -} - -#[lang="record_borrow"] -pub unsafe fn record_borrow(a: *u8, old_ref_count: uint, - file: *c_char, line: size_t) { - borrowck::record_borrow(a, old_ref_count, file, line) -} - -#[lang="unrecord_borrow"] -pub unsafe fn unrecord_borrow(a: *u8, old_ref_count: uint, - file: *c_char, line: size_t) { - borrowck::unrecord_borrow(a, old_ref_count, file, line) -} - -#[lang="return_to_mut"] -#[inline] -pub unsafe fn return_to_mut(a: *u8, orig_ref_count: uint, - file: *c_char, line: size_t) { - borrowck::return_to_mut(a, orig_ref_count, file, line) -} - -#[lang="check_not_borrowed"] -#[inline] -pub unsafe fn check_not_borrowed(a: *u8, - file: *c_char, - line: size_t) { - borrowck::check_not_borrowed(a, file, line) -}