Preliminary trace recording.

src/librustc_mir/transform/add_yk_swt_calls.rs

@@ -18,6 +18,11 @@ use rustc::hir;
 use rustc::hir::def_id::{DefIndex, LOCAL_CRATE};
 use rustc::hir::map::blocks::FnLikeNode;
 
+// These crates are not transformed by this MIR pass.
+// FIXME: Currently libstd and its deps are blacklisted. In the long run, we don't want this.
+static BLACKLISTED_CRATES: &'static [&'static str] = &["std", "alloc", "panic_unwind",
+    "panic_abort", "core", "libc", "profiler_builtins", "unwind"];
+
 /// A MIR transformation that, for each basic block, inserts a call to the software trace recorder.
 /// The arguments to the calls (crate hash, DefId and block index) identify the position to be
 /// inserted into a trace.
@@ -170,6 +175,11 @@ fn is_untraceable(tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource) -> bool {
         return true;
     }
 
+    // Don't transform any crate which is blacklisted. See the comment against BLACKLISTED_CRATES.
+    if BLACKLISTED_CRATES.contains(&&*tcx.crate_name(LOCAL_CRATE).as_str()) {
+        return true;
+    }
+
     // We can't transform promoted items, because they are `const`, and our trace recorder isn't.
     if let Some(_) = src.promoted {
         return true;

src/libstd/yk_swt.rs

@@ -7,6 +7,45 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use ::cell::RefCell;
+use ::fmt;
+
+#[allow(missing_docs)]
+/// A block location in the Rust MIR.
+pub struct MirLoc {
+    pub crate_hash: u64,
+    pub def_idx: u32,
+    pub bb_idx: u32,
+}
+
+impl fmt::Debug for MirLoc {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "loc<{}, {}, {}>", self.crate_hash, self.def_idx, self.bb_idx)
+    }
+}
+
+thread_local! {
+    /// The software trace currently being collected (if any).
+    /// When `Some`, a tracing is enabled, otherwise tracing is disabled.
+    pub static TRACE: RefCell<Option<Vec<MirLoc>>> = RefCell::new(None);
+}
+
+/// Start software tracing.
+#[cfg_attr(not(stage0), no_trace)]
+pub fn start_tracing() {
+    TRACE.with(|rc| {
+        let mut trace_o = rc.borrow_mut();
+        match *trace_o {
+            Some(_) => panic!("tracing was already started for this thread!"),
+            None => *trace_o = Some(Vec::new()),
+        }
+    });
+}
+
+// FIXME Anything used in `rec_loc` below cannot itself be traced, or we get infinite recursion. To
+// work around this, many crates are ignored by the software tracing MIR pass (see
+// librustc_mir/transform/add_yk_swt_calls.rs). Consider re-implementing the trace recorder in C?
+
 /// The software trace recorder function.
 /// The `AddYkSWTCalls` MIR pass injects a call this for every MIR block. The call is done
 /// indirectly via a wrapper in libcore.
@@ -15,5 +54,19 @@
 #[cfg_attr(not(stage0), no_trace)]
 #[cfg(not(test))]
 fn rec_loc(crate_hash: u64, def_idx: u32, bb_idx: u32) {
-    // Not implemented.
+    TRACE.with(|rc| {
+        let mut trace_o = rc.borrow_mut();
+        match trace_o.as_mut() {
+            Some(trace) => trace.push(MirLoc{crate_hash, def_idx, bb_idx}),
+            None => (), // We are not currently tracing, do nothing.
+        }
+    });
+}
+
+/// Stop tracing and return the trace.
+#[cfg_attr(not(stage0), no_trace)]
+pub fn stop_tracing() -> Vec<MirLoc> {
+    TRACE.with(|rc| {
+        rc.borrow_mut().take().expect("tracing not started on this thread")
+    })
 }

src/test/run-fail/yk_swt/trace-already-started.rs

@@ -0,0 +1,19 @@
+// Copyright 2019 King's College London.
+// Created by the Software Development Team <http://soft-dev.org/>.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: thread 'main' panicked at 'tracing was already started for this thread!'
+
+#![feature(yk_swt)]
+
+use std::yk_swt::{start_tracing, stop_tracing};
+
+pub fn main() {
+    start_tracing();
+    start_tracing(); // Can't call a second time without a stop_tracing() first.
+}

src/test/run-fail/yk_swt/trace-not-started.rs

@@ -0,0 +1,19 @@
+// Copyright 2019 King's College London.
+// Created by the Software Development Team <http://soft-dev.org/>.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: thread 'main' panicked at 'tracing not started on this thread'
+
+#![feature(yk_swt)]
+
+use std::yk_swt::{start_tracing, stop_tracing};
+
+pub fn main() {
+    // Missing start_tracing();
+    let _ = stop_tracing();
+}

src/test/run-pass/signal-alternate-stack-cleanup.rs

@@ -16,6 +16,10 @@
 // ignore-wasm32-bare no libc
 // ignore-windows
 
+// Software tracing breaks this test as the thread local used to record the trace becomes valid at
+// atexit() time.
+#![no_trace]
+
 #![feature(libc)]
 extern crate libc;
 

src/test/run-pass/thinlto/thin-lto-inlines2.rs

@@ -20,6 +20,8 @@
 // praying two functions go into separate codegen units and then assuming that
 // if inlining *doesn't* happen the first byte of the functions will differ.
 
+#![no_trace]
+
 extern crate thin_lto_inlines_aux as bar;
 
 pub fn foo() -> u32 {

src/test/run-pass/yk_swt/collect-trace.rs

@@ -0,0 +1,28 @@
+// Copyright 2019 King's College London.
+// Created by the Software Development Team <http://soft-dev.org/>.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(yk_swt)]
+
+use std::yk_swt::{start_tracing, stop_tracing};
+
+pub fn main() {
+    start_tracing();
+    let _ = work();
+    let trace = stop_tracing();
+    assert!(!trace.is_empty());
+}
+
+#[inline(never)]
+fn work() -> u64{
+    let mut res = 100;
+    for i in 0..10 {
+        res += res / 2 + i;
+    }
+    res
+}