---

yaml
---
r: 67504
b: refs/heads/master
c: 4700b00
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 05eff5f731fbdf0597bb6a4b94a7603571ff66b6
+refs/heads/master: 4700b00ef708f4babd86d72ba757e82d2369709e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libextra/dbg.rs

@@ -0,0 +1,80 @@
+// 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 <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.
+
+//! Unsafe debugging functions for inspecting values.
+
+#[allow(missing_doc)];
+
+use std::cast::transmute;
+use std::unstable::intrinsics::{get_tydesc};
+
+pub mod rustrt {
+    use std::unstable::intrinsics::{TyDesc};
+
+    #[abi = "cdecl"]
+    extern {
+        pub unsafe fn debug_tydesc(td: *TyDesc);
+        pub unsafe fn debug_opaque(td: *TyDesc, x: *());
+        pub unsafe fn debug_box(td: *TyDesc, x: *());
+        pub unsafe fn debug_tag(td: *TyDesc, x: *());
+        pub unsafe fn debug_fn(td: *TyDesc, x: *());
+        pub unsafe fn debug_ptrcast(td: *TyDesc, x: *()) -> *();
+        pub unsafe fn rust_dbg_breakpoint();
+    }
+}
+
+pub fn debug_tydesc<T>() {
+    unsafe {
+        rustrt::debug_tydesc(get_tydesc::<T>());
+    }
+}
+
+pub fn debug_opaque<T>(x: T) {
+    unsafe {
+        rustrt::debug_opaque(get_tydesc::<T>(), transmute(&x));
+    }
+}
+
+pub fn debug_box<T>(x: @T) {
+    unsafe {
+        rustrt::debug_box(get_tydesc::<T>(), transmute(&x));
+    }
+}
+
+pub fn debug_tag<T>(x: T) {
+    unsafe {
+        rustrt::debug_tag(get_tydesc::<T>(), transmute(&x));
+    }
+}
+
+pub fn debug_fn<T>(x: T) {
+    unsafe {
+        rustrt::debug_fn(get_tydesc::<T>(), transmute(&x));
+    }
+}
+
+pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
+    transmute(
+        rustrt::debug_ptrcast(get_tydesc::<T>(), transmute(x)))
+}
+
+/// Triggers a debugger breakpoint
+pub fn breakpoint() {
+    unsafe {
+        rustrt::rust_dbg_breakpoint();
+    }
+}
+
+#[test]
+fn test_breakpoint_should_not_abort_process_when_not_under_gdb() {
+    // Triggering a breakpoint involves raising SIGTRAP, which terminates
+    // the process under normal circumstances
+    breakpoint();
+}

trunk/src/libextra/extra.rs

@@ -78,6 +78,7 @@ pub mod sha2;
 
 pub mod url;
 pub mod ebml;
+pub mod dbg;
 pub mod getopts;
 pub mod json;
 pub mod md4;

trunk/src/libstd/unstable/lang.rs

@@ -41,6 +41,8 @@ pub mod rustrt {
 
         #[rust_stack]
         pub fn rust_try_get_task() -> *rust_task;
+
+        pub fn rust_dbg_breakpoint();
     }
 }
 

trunk/src/rt/rust_builtin.cpp

@@ -150,6 +150,93 @@ debug_static_mut_check_four() {
     assert(debug_static_mut == 4);
 }
 
+/* Debug builtins for std::dbg. */
+
+static void
+debug_tydesc_helper(type_desc *t)
+{
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "  size %" PRIdPTR ", align %" PRIdPTR,
+        t->size, t->align);
+}
+
+extern "C" CDECL void
+debug_tydesc(type_desc *t) {
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "debug_tydesc");
+    debug_tydesc_helper(t);
+}
+
+extern "C" CDECL void
+debug_opaque(type_desc *t, uint8_t *front) {
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "debug_opaque");
+    debug_tydesc_helper(t);
+    // Account for alignment. `front` may not indeed be the
+    // front byte of the passed-in argument
+    if (((uintptr_t)front % t->align) != 0) {
+        front = (uint8_t *)align_to((uintptr_t)front, (size_t)t->align);
+    }
+    for (uintptr_t i = 0; i < t->size; ++front, ++i) {
+        LOG(task, stdlib, "  byte %" PRIdPTR ": 0x%" PRIx8, i, *front);
+    }
+}
+
+extern "C" CDECL void
+debug_box(type_desc *t, rust_opaque_box *box) {
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "debug_box(0x%" PRIxPTR ")", box);
+    debug_tydesc_helper(t);
+    LOG(task, stdlib, "  refcount %" PRIdPTR,
+        box->ref_count - 1);  // -1 because we ref'ed for this call
+    uint8_t *data = (uint8_t *)box_body(box);
+    for (uintptr_t i = 0; i < t->size; ++i) {
+        LOG(task, stdlib, "  byte %" PRIdPTR ": 0x%" PRIx8, i, data[i]);
+    }
+}
+
+struct rust_tag {
+    uintptr_t discriminant;
+    uint8_t variant[];
+};
+
+extern "C" CDECL void
+debug_tag(type_desc *t, rust_tag *tag) {
+    rust_task *task = rust_get_current_task();
+
+    LOG(task, stdlib, "debug_tag");
+    debug_tydesc_helper(t);
+    LOG(task, stdlib, "  discriminant %" PRIdPTR, tag->discriminant);
+
+    for (uintptr_t i = 0; i < t->size - sizeof(tag->discriminant); ++i)
+        LOG(task, stdlib, "  byte %" PRIdPTR ": 0x%" PRIx8, i,
+            tag->variant[i]);
+}
+
+extern "C" CDECL void
+debug_fn(type_desc *t, fn_env_pair *fn) {
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "debug_fn");
+    debug_tydesc_helper(t);
+    LOG(task, stdlib, " fn at 0x%" PRIxPTR, fn->f);
+    LOG(task, stdlib, "  env at 0x%" PRIxPTR, fn->env);
+    if (fn->env) {
+        LOG(task, stdlib, "    refcount %" PRIdPTR, fn->env->ref_count);
+    }
+}
+
+extern "C" CDECL void *
+debug_ptrcast(type_desc *from_ty,
+              type_desc *to_ty,
+              void *ptr) {
+    rust_task *task = rust_get_current_task();
+    LOG(task, stdlib, "debug_ptrcast from");
+    debug_tydesc_helper(from_ty);
+    LOG(task, stdlib, "to");
+    debug_tydesc_helper(to_ty);
+    return ptr;
+}
+
 extern "C" CDECL void *
 debug_get_stk_seg() {
     rust_task *task = rust_get_current_task();
@@ -496,6 +583,11 @@ rust_should_log_console() {
     return (uintptr_t)should_log_console();
 }
 
+extern "C" CDECL void
+rust_dbg_breakpoint() {
+    BREAKPOINT_AWESOME;
+}
+
 extern "C" CDECL rust_sched_id
 rust_osmain_sched_id() {
     rust_task *task = rust_get_current_task();

trunk/src/rt/rust_debug.h

@@ -17,6 +17,19 @@
 #include <string>
 #include <cstdlib>
 
+#ifndef _WIN32
+
+#include <signal.h>
+#define BREAKPOINT_AWESOME                      \
+    do {                                        \
+        signal(SIGTRAP, SIG_IGN);               \
+        raise(SIGTRAP);                         \
+    } while (0)
+
+#else
+#define BREAKPOINT_AWESOME
+#endif
+
 struct rust_task;
 
 namespace debug {

trunk/src/rt/rustrt.def.in

@@ -1,3 +1,9 @@
+debug_box
+debug_fn
+debug_opaque
+debug_ptrcast
+debug_tag
+debug_tydesc
 debug_get_stk_seg
 debug_abi_1
 debug_abi_2
@@ -172,6 +178,7 @@ rust_dbg_lock_wait
 rust_dbg_lock_signal
 rust_dbg_call
 rust_dbg_do_nothing
+rust_dbg_breakpoint
 rust_osmain_sched_id
 rust_task_inhibit_kill
 rust_task_allow_kill

trunk/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2013-07-31 389aba0
+  freebsd-x86_64 c9783bb5723404be8ae371d265bbb9a1c679e4db
+  linux-i386 7413d98325b23dc461ced92757e5e19bec750dbd
+  linux-x86_64 cd3fedbb02423f330aedaae6173914659ccb98e5
+  macos-i386 fef296e534b5e12d382708e658370957d5df9a0e
+  macos-x86_64 57bd3da763607386a08b2a50ecf5a7778aea8356
+  winnt-i386 a532aaabf043370a21458fd6874be41d432b5696
+
 S 2013-07-25 4cf3072
   macos-i386 f682d6e9ca0d56768bd36a0c05b7e58e12694dff
   macos-x86_64 2f4e85c9756ba31a04fa8dd1c999fbaf8e1d3d1a