add a new debugging aid--tracing

Author: nikomatsakis

src/rt/rust_upcall.cpp

@@ -129,6 +129,28 @@ upcall_fail(char const *expr,
     UPCALL_SWITCH_STACK(&args, upcall_s_fail);
 }
 
+struct s_trace_args {
+    char const *msg;
+    char const *file;
+    size_t line;
+};
+
+extern "C" CDECL void
+upcall_s_trace(s_trace_args *args) {
+    rust_task *task = rust_get_current_task();
+    LOG_UPCALL_ENTRY(task);
+    LOG(task, trace, "Trace %s:%d: %s",
+        args->file, args->line, args->msg);
+}
+
+extern "C" CDECL void
+upcall_trace(char const *msg,
+             char const *file,
+             size_t line) {
+    s_trace_args args = {msg,file,line};
+    UPCALL_SWITCH_STACK(&args, upcall_s_trace);
+}
+
 /**********************************************************************
  * Allocate an object in the task-local heap.
  */

src/rt/rustrt.def.in

@@ -65,6 +65,7 @@ vec_from_buf_shared
 unsupervise
 upcall_cmp_type
 upcall_fail
+upcall_trace
 upcall_free
 upcall_validate_box
 upcall_log_type

src/rustc/back/upcall.rs

@@ -9,6 +9,7 @@ import lib::llvm::{type_names, ModuleRef, ValueRef, TypeRef};
 
 type upcalls =
     {_fail: ValueRef,
+     trace: ValueRef,
      malloc: ValueRef,
      free: ValueRef,
      validate_box: ValueRef,
@@ -53,6 +54,9 @@ fn declare_upcalls(targ_cfg: @session::config,
     ret @{_fail: dv("fail", [T_ptr(T_i8()),
                              T_ptr(T_i8()),
                              size_t]),
+          trace: dv("trace", [T_ptr(T_i8()),
+                              T_ptr(T_i8()),
+                              int_t]),
           malloc:
               nothrow(d("malloc", [T_ptr(tydesc_type)],
                         T_ptr(T_i8()))),

src/rustc/driver/session.rs

@@ -30,6 +30,7 @@ const time_llvm_passes: uint = 8u;
 const stats: uint = 16u;
 const no_asm_comments: uint = 32u;
 const no_verify: uint = 64u;
+const trace: uint = 128u;
 
 fn debugging_opts_map() -> [(str, str, uint)] {
     [("ppregions", "prettyprint regions with \
@@ -40,7 +41,8 @@ fn debugging_opts_map() -> [(str, str, uint)] {
      ("time-llvm-passes", "measure time of each LLVM pass", time_llvm_passes),
      ("stats", "gather trans statistics", stats),
      ("no-asm-comments", "omit comments when using -S", no_asm_comments),
-     ("no-verify", "skip LLVM verification", no_verify)]
+     ("no-verify", "skip LLVM verification", no_verify),
+     ("trace", "emit trace logs", trace)]
 }
 
 type options =
@@ -141,6 +143,7 @@ impl session for session {
     fn stats() -> bool { self.debugging_opt(stats) }
     fn no_asm_comments() -> bool { self.debugging_opt(no_asm_comments) }
     fn no_verify() -> bool { self.debugging_opt(no_verify) }
+    fn trace() -> bool { self.debugging_opt(trace) }
 }
 
 #[doc = "Some reasonable defaults"]

src/rustc/middle/trans/base.rs

@@ -1683,10 +1683,12 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
 
 fn root_value(bcx: block, val: ValueRef, ty: ty::t,
               scope_id: ast::node_id) {
-    if !bcx.sess().no_asm_comments() {
-        add_comment(bcx, #fmt["preserving until end of scope %d",
-                              scope_id]);
+    if bcx.sess().trace() {
+        trans_trace(
+            bcx, none,
+            #fmt["preserving until end of scope %d", scope_id]);
     }
+
     let root_loc = alloca(bcx, type_of(bcx.ccx(), ty));
     copy_val(bcx, INIT, root_loc, val, ty);
     add_root_cleanup(bcx, scope_id, root_loc, ty);
@@ -3725,6 +3727,30 @@ fn trans_fail_expr(bcx: block, sp_opt: option<span>,
     }
 }
 
+fn trans_trace(bcx: block, sp_opt: option<span>, trace_str: str) {
+    if !bcx.sess().trace() { ret; }
+    let _icx = bcx.insn_ctxt("trans_trace");
+    add_comment(bcx, trace_str);
+    let V_trace_str = C_cstr(bcx.ccx(), trace_str);
+    let {V_filename, V_line} = alt sp_opt {
+      some(sp) {
+        let sess = bcx.sess();
+        let loc = codemap::lookup_char_pos(sess.parse_sess.cm, sp.lo);
+        {V_filename: C_cstr(bcx.ccx(), loc.file.name),
+         V_line: loc.line as int}
+      }
+      none {
+        {V_filename: C_cstr(bcx.ccx(), "<runtime>"),
+         V_line: 0}
+      }
+    };
+    let ccx = bcx.ccx();
+    let V_trace_str = PointerCast(bcx, V_trace_str, T_ptr(T_i8()));
+    let V_filename = PointerCast(bcx, V_filename, T_ptr(T_i8()));
+    let args = [V_trace_str, V_filename, C_int(ccx, V_line)];
+    Call(bcx, ccx.upcalls.trace, args);
+}
+
 fn trans_fail(bcx: block, sp_opt: option<span>, fail_str: str) ->
     block {
     let _icx = bcx.insn_ctxt("trans_fail");
@@ -4040,8 +4066,10 @@ fn cleanup_and_leave(bcx: block, upto: option<BasicBlockRef>,
     loop {
         #debug["cleanup_and_leave: leaving %s", cur.to_str()];
 
-        if !bcx.sess().no_asm_comments() {
-            add_comment(bcx, #fmt["cleanup_and_leave(%s)", cur.to_str()]);
+        if bcx.sess().trace() {
+            trans_trace(
+                bcx, none,
+                #fmt["cleanup_and_leave(%s)", cur.to_str()]);
         }
 
         alt cur.kind {

src/rustc/middle/trans/build.rs

@@ -669,6 +669,11 @@ fn Call(cx: block, Fn: ValueRef, Args: [ValueRef]) -> ValueRef {
     if cx.unreachable { ret _UndefReturn(cx, Fn); }
     unsafe {
         count_insn(cx, "call");
+
+        #debug["Call(Fn=%s, Args=%?)",
+               val_str(cx.ccx().tn, Fn),
+               Args.map { |arg| val_str(cx.ccx().tn, arg) }];
+
         ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
                                 Args.len() as c_uint, noname());
     }