Skip to content
Standard libraryZig 0.17.1Official documentation
Sourcestd/valgrind.zig

Source line 1

std.valgrind.builtin

constant

Source line 1

std.valgrind.cachegrind

alias

Source line 319

Alias of std.valgrind.cachegrind

std.valgrind.callgrind

alias

Source line 318

Alias of std.valgrind.callgrind

std.valgrind.ClientRequest

container

Source line 106

Fields

RunningOnValgrind = 4097
DiscardTranslations = 4098
ClientCall0 = 4353
ClientCall1 = 4354
ClientCall2 = 4355
ClientCall3 = 4356
CountErrors = 4609
GdbMonitorCommand = 4610
MalloclikeBlock = 4865
ResizeinplaceBlock = 4875
FreelikeBlock = 4866
CreateMempool = 4867
DestroyMempool = 4868
MempoolAlloc = 4869
MempoolFree = 4870
MempoolTrim = 4871
MoveMempool = 4872
MempoolChange = 4873
MempoolExists = 4874
Printf = 5121
PrintfBacktrace = 5122
PrintfValistByRef = 5123
PrintfBacktraceValistByRef = 5124
StackRegister = 5377
StackDeregister = 5378
StackChange = 5379
LoadPdbDebuginfo = 5633
MapIpToSrcloc = 5889
ChangeErrDisablement = 6145
VexInitForIri = 6401
InnerThreads = 6402

std.valgrind.countErrors

function

Source line 196

Counts the number of errors that have been recorded by a tool. Nb: the tool must record the errors with VG_(maybe_record_error)() or VG_(unique_error)() for them to be counted.

pub fn countErrors() usize

std.valgrind.createMempool

function

Source line 218

pub fn createMempool(pool: [*]u8, rzB: usize, is_zeroed: bool, flags: usize) void

Parameters

pool: [*]u8
rzB: usize
is_zeroed: bool
flags: usize

std.valgrind.destroyMempool

function

Source line 223

Destroy a memory pool.

pub fn destroyMempool(pool: [*]u8) void

Parameters

pool: [*]u8

std.valgrind.disableErrorReporting

function

Source line 299

Disable error reporting for this thread. Behaves in a stack like way, so you can safely call this multiple times provided that enableErrorReporting() is called the same number of times to re-enable reporting. The first call of this macro disables reporting. Subsequent calls have no effect except to increase the number of enableErrorReporting() calls needed to re-enable reporting. Child threads do not inherit this setting from their parents -- they are always created with reporting enabled.

pub fn disableErrorReporting() void

std.valgrind.discardTranslations

function

Source line 169

Discard translation of code in the slice qzz. Useful if you are debugging a JITter or some such, since it provides a way to make sure valgrind will retranslate the invalidated area. Returns no value.

pub fn discardTranslations(qzz: []const u8) void

Parameters

qzz: []const u8

std.valgrind.doClientRequest

function

Source line 5

pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize

Parameters

default: usize
request: usize
a1: usize
a2: usize
a3: usize
a4: usize
a5: usize

std.valgrind.doClientRequestExpr

function

Source line 146

fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize

Parameters

default: usize
request: ClientRequest
a1: usize
a2: usize
a3: usize
a4: usize
a5: usize

std.valgrind.doClientRequestStmt

function

Source line 150

fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void

Parameters

request: ClientRequest
a1: usize
a2: usize
a3: usize
a4: usize
a5: usize

std.valgrind.enableErrorReporting

function

Source line 304

Re-enable error reporting. (see disableErrorReporting())

pub fn enableErrorReporting() void

std.valgrind.freeLikeBlock

function

Source line 209

pub fn freeLikeBlock(addr: [*]u8, rzB: usize) void

Parameters

addr: [*]u8
rzB: usize

std.valgrind.innerThreads

function

Source line 173

pub fn innerThreads(qzz: [*]u8) void

Parameters

qzz: [*]u8

std.valgrind.IsTool

function

Source line 142

pub fn IsTool(base: [2]u8, code: usize) bool

Parameters

base: [2]u8
code: usize

std.valgrind.mallocLikeBlock

function

Source line 201

pub fn mallocLikeBlock(mem: []u8, rzB: usize, is_zeroed: bool) void

Parameters

mem: []u8
rzB: usize
is_zeroed: bool

std.valgrind.mapIpToSrcloc

function

Source line 287

Map a code address to a source file name and line number. buf64 must point to a 64-byte buffer in the caller's address space. The result will be dumped in there and is guaranteed to be zero terminated. If no info is found, the first byte is set to zero.

pub fn mapIpToSrcloc(addr: *const u8, buf64: [64]u8) usize

Parameters

addr: *const u8
buf64: [64]u8

std.valgrind.math

alias

Source line 3

Alias of std.math

std.valgrind.memcheck

alias

Source line 317

Alias of std.valgrind.memcheck

std.valgrind.mempoolAlloc

function

Source line 228

Associate a piece of memory with a memory pool.

pub fn mempoolAlloc(pool: [*]u8, mem: []u8) void

Parameters

pool: [*]u8
mem: []u8

std.valgrind.mempoolChange

function

Source line 248

Resize and/or move a piece associated with a memory pool.

pub fn mempoolChange(pool: [*]u8, addrA: [*]u8, mem: []u8) void

Parameters

pool: [*]u8
addrA: [*]u8
mem: []u8

std.valgrind.mempoolExists

function

Source line 253

Return if a mempool exists.

pub fn mempoolExists(pool: [*]u8) bool

Parameters

pool: [*]u8

std.valgrind.MempoolFlags

namespace

Source line 214

Create a memory pool.

std.valgrind.MempoolFlags.AutoFree

constant

Source line 215

std.valgrind.MempoolFlags.MetaPool

constant

Source line 216

std.valgrind.mempoolFree

function

Source line 233

Disassociate a piece of memory from a memory pool.

pub fn mempoolFree(pool: [*]u8, addr: [*]u8) void

Parameters

pool: [*]u8
addr: [*]u8

std.valgrind.mempoolTrim

function

Source line 238

Disassociate any pieces outside a particular range.

pub fn mempoolTrim(pool: [*]u8, mem: []u8) void

Parameters

pool: [*]u8
mem: []u8

std.valgrind.monitorCommand

function

Source line 313

Execute a monitor command from the client program. If a connection is opened with GDB, the output will be sent according to the output mode set for vgdb. If no connection is opened, output will go to the log output. Returns 1 if command not recognised, 0 otherwise.

pub fn monitorCommand(command: [*]u8) bool

Parameters

command: [*]u8

std.valgrind.moveMempool

function

Source line 243

Resize and/or move a piece associated with a memory pool.

pub fn moveMempool(poolA: [*]u8, poolB: [*]u8) void

Parameters

poolA: [*]u8
poolB: [*]u8

std.valgrind.nonSimdCall0

function

Source line 177

pub fn nonSimdCall0(func: fn (usize) usize) usize

Parameters

func: fn (usize) usize

std.valgrind.nonSimdCall1

function

Source line 181

pub fn nonSimdCall1(func: fn (usize, usize) usize, a1: usize) usize

Parameters

func: fn (usize, usize) usize
a1: usize

std.valgrind.nonSimdCall2

function

Source line 185

pub fn nonSimdCall2(func: fn (usize, usize, usize) usize, a1: usize, a2: usize) usize

Parameters

func: fn (usize, usize, usize) usize
a1: usize
a2: usize

std.valgrind.nonSimdCall3

function

Source line 189

pub fn nonSimdCall3(func: fn (usize, usize, usize, usize) usize, a1: usize, a2: usize, a3: usize) usize

Parameters

func: fn (usize, usize, usize, usize) usize
a1: usize
a2: usize
a3: usize

std.valgrind.resizeInPlaceBlock

function

Source line 205

pub fn resizeInPlaceBlock(oldmem: []u8, newsize: usize, rzB: usize) void

Parameters

oldmem: []u8
newsize: usize
rzB: usize

std.valgrind.runningOnValgrind

function

Source line 158

Returns the number of Valgrinds this code is running under. That is, 0 if running natively, 1 if running under Valgrind, 2 if running under Valgrind which is running under another Valgrind, etc.

pub fn runningOnValgrind() usize

std.valgrind.stackChange

function

Source line 272

Change the start and end address of the stack id. start is the new lowest addressable stack byte, end is the new highest addressable stack byte.

pub fn stackChange(id: usize, newstack: []u8) void

Parameters

id: usize
newstack: []u8

std.valgrind.stackDeregister

function

Source line 265

Unmark the piece of memory associated with a stack id as being a stack.

pub fn stackDeregister(id: usize) void

Parameters

id: usize

std.valgrind.stackRegister

function

Source line 260

Mark a piece of memory as being a stack. Returns a stack id. start is the lowest addressable stack byte, end is the highest addressable stack byte.

pub fn stackRegister(stack: []u8) usize

Parameters

stack: []u8

std.valgrind.std

alias

Source line 2

Alias of std

std.valgrind.ToolBase

function

Source line 139

pub fn ToolBase(base: [2]u8) u32

Parameters

base: [2]u8
Source code

std/valgrind.zig

const builtin = @import("builtin");
const std = @import("std.zig");
const math = std.math;

pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
    if (!builtin.valgrind_support) {
        return default;
    }

    const args = &[_]usize{ request, a1, a2, a3, a4, a5 };

    return switch (builtin.cpu.arch) {
        .arm, .armeb, .thumb, .thumbeb => asm volatile (
            \\ mov r12, r12, ror #3  ; mov r12, r12, ror #13
            \\ mov r12, r12, ror #29 ; mov r12, r12, ror #19
            \\ orr r10, r10, r10
            : [_] "={r3}" (-> usize),
            : [_] "{r4}" (args),
              [_] "{r3}" (default),
            : .{ .memory = true }),
        .aarch64, .aarch64_be => asm volatile (
            \\ ror x12, x12, #3  ; ror x12, x12, #13
            \\ ror x12, x12, #51 ; ror x12, x12, #61
            \\ orr x10, x10, x10
            : [_] "={x3}" (-> usize),
            : [_] "{x4}" (args),
              [_] "{x3}" (default),
            : .{ .memory = true }),
        .mips, .mipsel => asm volatile (
            \\ srl $0,  $0,  13
            \\ srl $0,  $0,  29
            \\ srl $0,  $0,  3
            \\ srl $0,  $0,  19
            \\ or  $13, $13, $13
            : [_] "={$11}" (-> usize),
            : [_] "{$12}" (args),
              [_] "{$11}" (default),
            : .{ .memory = true }),
        .mips64, .mips64el => asm volatile (
            \\ dsll $0,  $0,  3   ; dsll $0, $0, 13
            \\ dsll $0,  $0,  29  ; dsll $0, $0, 19
            \\ or   $13, $13, $13
            : [_] "={$11}" (-> usize),
            : [_] "{$12}" (args),
              [_] "{$11}" (default),
            : .{ .memory = true }),
        .powerpc, .powerpcle => asm volatile (
            \\ rlwinm 0, 0, 3,  0, 31 ; rlwinm 0, 0, 13, 0, 31
            \\ rlwinm 0, 0, 29, 0, 31 ; rlwinm 0, 0, 19, 0, 31
            \\ or     1, 1, 1
            : [_] "={r3}" (-> usize),
            : [_] "{r4}" (args),
              [_] "{r3}" (default),
            : .{ .memory = true }),
        .powerpc64, .powerpc64le => asm volatile (
            \\ rotldi 0, 0, 3  ; rotldi 0, 0, 13
            \\ rotldi 0, 0, 61 ; rotldi 0, 0, 51
            \\ or     1, 1, 1
            : [_] "={r3}" (-> usize),
            : [_] "{r4}" (args),
              [_] "{r3}" (default),
            : .{ .memory = true }),
        .riscv64 => asm volatile (
            \\ .option push
            \\ .option norvc
            \\ srli zero, zero, 3
            \\ srli zero, zero, 13
            \\ srli zero, zero, 51
            \\ srli zero, zero, 61
            \\ or   a0,   a0,   a0
            \\ .option pop
            : [_] "={a3}" (-> usize),
            : [_] "{a4}" (args),
              [_] "{a3}" (default),
            : .{ .memory = true }),
        .s390x => asm volatile (
            \\ lr %%r15, %%r15
            \\ lr %%r1,  %%r1
            \\ lr %%r2,  %%r2
            \\ lr %%r3,  %%r3
            \\ lr %%r2,  %%r2
            : [_] "={r3}" (-> usize),
            : [_] "{r2}" (args),
              [_] "{r3}" (default),
            : .{ .memory = true }),
        .x86 => asm volatile (
            \\ roll  $3,    %%edi ; roll $13, %%edi
            \\ roll  $29,   %%edi ; roll $19, %%edi
            \\ xchgl %%ebx, %%ebx
            : [_] "={edx}" (-> usize),
            : [_] "{eax}" (args),
              [_] "{edx}" (default),
            : .{ .memory = true }),
        .x86_64 => asm volatile (
            \\ rolq  $3,    %%rdi ; rolq $13, %%rdi
            \\ rolq  $61,   %%rdi ; rolq $51, %%rdi
            \\ xchgq %%rbx, %%rbx
            : [_] "={rdx}" (-> usize),
            : [_] "{rax}" (args),
              [_] "{rdx}" (default),
            : .{ .memory = true }),
        else => default,
    };
}

pub const ClientRequest = enum(u32) {
    RunningOnValgrind = 4097,
    DiscardTranslations = 4098,
    ClientCall0 = 4353,
    ClientCall1 = 4354,
    ClientCall2 = 4355,
    ClientCall3 = 4356,
    CountErrors = 4609,
    GdbMonitorCommand = 4610,
    MalloclikeBlock = 4865,
    ResizeinplaceBlock = 4875,
    FreelikeBlock = 4866,
    CreateMempool = 4867,
    DestroyMempool = 4868,
    MempoolAlloc = 4869,
    MempoolFree = 4870,
    MempoolTrim = 4871,
    MoveMempool = 4872,
    MempoolChange = 4873,
    MempoolExists = 4874,
    Printf = 5121,
    PrintfBacktrace = 5122,
    PrintfValistByRef = 5123,
    PrintfBacktraceValistByRef = 5124,
    StackRegister = 5377,
    StackDeregister = 5378,
    StackChange = 5379,
    LoadPdbDebuginfo = 5633,
    MapIpToSrcloc = 5889,
    ChangeErrDisablement = 6145,
    VexInitForIri = 6401,
    InnerThreads = 6402,
};
pub fn ToolBase(base: [2]u8) u32 {
    return (@as(u32, base[0] & 0xff) << 24) | (@as(u32, base[1] & 0xff) << 16);
}
pub fn IsTool(base: [2]u8, code: usize) bool {
    return ToolBase(base) == (code & 0xffff0000);
}

fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize {
    return doClientRequest(default, @as(usize, @intCast(@backingInt(request))), a1, a2, a3, a4, a5);
}

fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void {
    _ = doClientRequestExpr(0, request, a1, a2, a3, a4, a5);
}

/// Returns the number of Valgrinds this code is running under.  That
/// is, 0 if running natively, 1 if running under Valgrind, 2 if
/// running under Valgrind which is running under another Valgrind,
/// etc.
pub fn runningOnValgrind() usize {
    return doClientRequestExpr(0, .RunningOnValgrind, 0, 0, 0, 0, 0);
}

test "works whether running on valgrind or not" {
    _ = runningOnValgrind();
}

/// Discard translation of code in the slice qzz.  Useful if you are debugging
/// a JITter or some such, since it provides a way to make sure valgrind will
/// retranslate the invalidated area.  Returns no value.
pub fn discardTranslations(qzz: []const u8) void {
    doClientRequestStmt(.DiscardTranslations, @intFromPtr(qzz.ptr), qzz.len, 0, 0, 0);
}

pub fn innerThreads(qzz: [*]u8) void {
    doClientRequestStmt(.InnerThreads, @intFromPtr(qzz), 0, 0, 0, 0);
}

pub fn nonSimdCall0(func: fn (usize) usize) usize {
    return doClientRequestExpr(0, .ClientCall0, @intFromPtr(func), 0, 0, 0, 0);
}

pub fn nonSimdCall1(func: fn (usize, usize) usize, a1: usize) usize {
    return doClientRequestExpr(0, .ClientCall1, @intFromPtr(func), a1, 0, 0, 0);
}

pub fn nonSimdCall2(func: fn (usize, usize, usize) usize, a1: usize, a2: usize) usize {
    return doClientRequestExpr(0, .ClientCall2, @intFromPtr(func), a1, a2, 0, 0);
}

pub fn nonSimdCall3(func: fn (usize, usize, usize, usize) usize, a1: usize, a2: usize, a3: usize) usize {
    return doClientRequestExpr(0, .ClientCall3, @intFromPtr(func), a1, a2, a3, 0);
}

/// Counts the number of errors that have been recorded by a tool.  Nb:
/// the tool must record the errors with VG_(maybe_record_error)() or
/// VG_(unique_error)() for them to be counted.
pub fn countErrors() usize {
    return doClientRequestExpr(0, // default return
        .CountErrors, 0, 0, 0, 0, 0);
}

pub fn mallocLikeBlock(mem: []u8, rzB: usize, is_zeroed: bool) void {
    doClientRequestStmt(.MalloclikeBlock, @intFromPtr(mem.ptr), mem.len, rzB, @intFromBool(is_zeroed), 0);
}

pub fn resizeInPlaceBlock(oldmem: []u8, newsize: usize, rzB: usize) void {
    doClientRequestStmt(.ResizeinplaceBlock, @intFromPtr(oldmem.ptr), oldmem.len, newsize, rzB, 0);
}

pub fn freeLikeBlock(addr: [*]u8, rzB: usize) void {
    doClientRequestStmt(.FreelikeBlock, @intFromPtr(addr), rzB, 0, 0, 0);
}

/// Create a memory pool.
pub const MempoolFlags = struct {
    pub const AutoFree = 1;
    pub const MetaPool = 2;
};
pub fn createMempool(pool: [*]u8, rzB: usize, is_zeroed: bool, flags: usize) void {
    doClientRequestStmt(.CreateMempool, @intFromPtr(pool), rzB, @intFromBool(is_zeroed), flags, 0);
}

/// Destroy a memory pool.
pub fn destroyMempool(pool: [*]u8) void {
    doClientRequestStmt(.DestroyMempool, @intFromPtr(pool), 0, 0, 0, 0);
}

/// Associate a piece of memory with a memory pool.
pub fn mempoolAlloc(pool: [*]u8, mem: []u8) void {
    doClientRequestStmt(.MempoolAlloc, @intFromPtr(pool), @intFromPtr(mem.ptr), mem.len, 0, 0);
}

/// Disassociate a piece of memory from a memory pool.
pub fn mempoolFree(pool: [*]u8, addr: [*]u8) void {
    doClientRequestStmt(.MempoolFree, @intFromPtr(pool), @intFromPtr(addr), 0, 0, 0);
}

/// Disassociate any pieces outside a particular range.
pub fn mempoolTrim(pool: [*]u8, mem: []u8) void {
    doClientRequestStmt(.MempoolTrim, @intFromPtr(pool), @intFromPtr(mem.ptr), mem.len, 0, 0);
}

/// Resize and/or move a piece associated with a memory pool.
pub fn moveMempool(poolA: [*]u8, poolB: [*]u8) void {
    doClientRequestStmt(.MoveMempool, @intFromPtr(poolA), @intFromPtr(poolB), 0, 0, 0);
}

/// Resize and/or move a piece associated with a memory pool.
pub fn mempoolChange(pool: [*]u8, addrA: [*]u8, mem: []u8) void {
    doClientRequestStmt(.MempoolChange, @intFromPtr(pool), @intFromPtr(addrA), @intFromPtr(mem.ptr), mem.len, 0);
}

/// Return if a mempool exists.
pub fn mempoolExists(pool: [*]u8) bool {
    return doClientRequestExpr(0, .MempoolExists, @intFromPtr(pool), 0, 0, 0, 0) != 0;
}

/// Mark a piece of memory as being a stack. Returns a stack id.
/// start is the lowest addressable stack byte, end is the highest
/// addressable stack byte.
pub fn stackRegister(stack: []u8) usize {
    return doClientRequestExpr(0, .StackRegister, @intFromPtr(stack.ptr), @intFromPtr(stack.ptr) + stack.len, 0, 0, 0);
}

/// Unmark the piece of memory associated with a stack id as being a stack.
pub fn stackDeregister(id: usize) void {
    doClientRequestStmt(.StackDeregister, id, 0, 0, 0, 0);
}

/// Change the start and end address of the stack id.
/// start is the new lowest addressable stack byte, end is the new highest
/// addressable stack byte.
pub fn stackChange(id: usize, newstack: []u8) void {
    doClientRequestStmt(.StackChange, id, @intFromPtr(newstack.ptr), @intFromPtr(newstack.ptr) + newstack.len, 0, 0);
}

// Load PDB debug info for Wine PE image_map.
// pub fn loadPdbDebuginfo(fd, ptr, total_size, delta) void {
//     doClientRequestStmt(.LoadPdbDebuginfo,
//         fd, ptr, total_size, delta,
//         0);
// }

/// Map a code address to a source file name and line number.  buf64
/// must point to a 64-byte buffer in the caller's address space. The
/// result will be dumped in there and is guaranteed to be zero
/// terminated.  If no info is found, the first byte is set to zero.
pub fn mapIpToSrcloc(addr: *const u8, buf64: [64]u8) usize {
    return doClientRequestExpr(0, .MapIpToSrcloc, @intFromPtr(addr), @intFromPtr(&buf64[0]), 0, 0, 0);
}

/// Disable error reporting for this thread.  Behaves in a stack like
/// way, so you can safely call this multiple times provided that
/// enableErrorReporting() is called the same number of times
/// to re-enable reporting.  The first call of this macro disables
/// reporting.  Subsequent calls have no effect except to increase the
/// number of enableErrorReporting() calls needed to re-enable
/// reporting.  Child threads do not inherit this setting from their
/// parents -- they are always created with reporting enabled.
pub fn disableErrorReporting() void {
    doClientRequestStmt(.ChangeErrDisablement, 1, 0, 0, 0, 0);
}

/// Re-enable error reporting. (see disableErrorReporting())
pub fn enableErrorReporting() void {
    doClientRequestStmt(.ChangeErrDisablement, math.maxInt(usize), 0, 0, 0, 0);
}

/// Execute a monitor command from the client program.
/// If a connection is opened with GDB, the output will be sent
/// according to the output mode set for vgdb.
/// If no connection is opened, output will go to the log output.
/// Returns 1 if command not recognised, 0 otherwise.
pub fn monitorCommand(command: [*]u8) bool {
    return doClientRequestExpr(0, .GdbMonitorCommand, @intFromPtr(command), 0, 0, 0, 0) != 0;
}

pub const memcheck = @import("valgrind/memcheck.zig");
pub const callgrind = @import("valgrind/callgrind.zig");
pub const cachegrind = @import("valgrind/cachegrind.zig");

test {
    _ = memcheck;
    _ = callgrind;
    _ = cachegrind;
}