crabgrind 0.2.5

Rust bindings to "Valgrind Client Request" interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

pub mod cachegrind;
pub mod callgrind;
pub mod dhat;
pub mod drd;
pub mod helgrind;
pub mod memcheck;
pub mod valgrind;

pub(crate) mod constants;

macro_rules! client_request {
    (^ $($arg:expr),*) =>  {{
        #[cfg(not(feature = "opt-out"))]
        unsafe { $crate::bindings::valgrind_client_request_expr($($arg as usize),*) }

        #[cfg(feature = "opt-out")]
        ($($arg as usize),*).0
    }};
    ($request:path, $arg1:expr, $arg2:expr, $arg3:expr, $arg4:expr, $arg5:expr) => {{
        $crate::requests::assert_defined!($request);
        client_request!(^ 0, $request, $arg1, $arg2, $arg3, $arg4, $arg5)
    }};
    ($request:path, $arg1:expr, $arg2:expr, $arg3:expr, $arg4:expr) => {
        client_request!($request, $arg1, $arg2, $arg3, $arg4, 0)
    };
    ($request:path, $arg1:expr, $arg2:expr, $arg3:expr) => {
        client_request!($request, $arg1, $arg2, $arg3, 0, 0)
    };
    ($request:path, $arg1:expr, $arg2:expr) => {
        client_request!($request, $arg1, $arg2, 0, 0, 0)
    };
    ($request:path, $arg1:expr) => {
        client_request!($request, $arg1, 0, 0, 0, 0)
    };
    ($request:path) => {
        client_request!($request, 0, 0, 0, 0, 0)
    };
}

// Asserts that a client request is supported by the Valgrind version this crate was compiled against.
// These assertions are expected to be optimized out by the compiler for supported requests.
macro_rules! assert_defined {
    ($request:path) => {{
        const REQUIREMENT: u32 = $request.required_version();
        const SYS_VERSION: u32 = crate::VALGRIND_VERSION.0 * 100 + crate::VALGRIND_VERSION.1;

        // check Valgrind headers indeed found 
        assert_ne!(0, SYS_VERSION,
            "\n`bindgen(libclang)` failed to locate `<valgrind/valgrind.h>`.\n\
            \tThis typically means Valgrind headers ain't found on the standard include paths:\n\
            \t\t<sysroot>/usr/include\n\
            \t\t<sysroot>/usr/local/include\n\
            \t\t...\n\
            \t\t\tnor via 'pkg-config' probe.\n\
            \tYou might try 'VALGRIND_INCLUDE=<path to valgrind/include>' as a quick workaround.\n\
            \tBuild configuration doc: https://docs.rs/crabgrind#build-configuration");

        // check request requirement matches local Valgrind version
        assert!(
            REQUIREMENT <= SYS_VERSION,
            "\n'{request}' is not supported by your Valgrind version. \n\
                \t You are compiling against <valgrind/valgrind.h> {major}.{minor}. \n\
                \t This request requires Valgrind {req_major}.{req_minor} or higher.\n",
            request = &stringify!($request)[7..], // CR::CG_*
            major = crate::VALGRIND_VERSION.0,
            minor = crate::VALGRIND_VERSION.1,
            req_major = REQUIREMENT / 100,
            req_minor = REQUIREMENT % 100,
        );
    }};
}

pub(crate) use {assert_defined, client_request};

#[doc = include_str!("../../doc/println.md")]
#[macro_export]
macro_rules! println{
    ($($arg:tt)+) => {{
        let msg = format!("{}\n\0", format_args!($($arg)+));

        let msg = unsafe { core::ffi::CStr::from_bytes_with_nul_unchecked(msg.as_bytes()) };
        $crate::__print(msg);
    }}
}

#[doc = include_str!("../../doc/println_stacktrace.md")]
#[macro_export]
macro_rules! print_stacktrace{
    ($($arg:tt)+) => {{
        let msg = format!("{}\0", format_args!($($arg)+));

        let msg = unsafe { core::ffi::CStr::from_bytes_with_nul_unchecked(msg.as_bytes()) };
        $crate::__print_stacktrace(msg);
    }}
}

/// Behavior for a logically scoped requests.
pub trait Scope: sealed::Sealed {
    type Inner: Copy;

    fn enter(arg: Self::Inner);
    fn exit(arg: Self::Inner);
}

#[doc = include_str!("../../doc/ScopeGuard.md")]
#[clippy::has_significant_drop]
#[derive(Debug)]
#[must_use = "The guard activates immediately upon creation. Dropping it instantly reverts the operation."]
pub struct ScopeGuard<S: Scope> {
    inner: S::Inner,
    _marker: core::marker::PhantomData<S>,
}

impl<S: Scope> ScopeGuard<S> {
    #[inline(always)]
    fn new(inner: S::Inner) -> Self {
        S::enter(inner);

        Self { inner, _marker: core::marker::PhantomData }
    }
}

impl<S: Scope> Drop for ScopeGuard<S> {
    #[inline(always)]
    fn drop(&mut self) {
        S::exit(self.inner);
    }
}

mod sealed {
    pub trait Sealed {}
}