Compiler Explorer

zig source #1

Compiler

Options

Source code

export fn absdiff1(a: usize, b: usize) usize {
    return @max(a, b) - @min(a, b);
}
export fn absdiff2(a: usize, b: usize) usize {
    if (a > b) {
        return a - b;
    }
    return b - a;
}
export fn absdiff3(a: usize, b: usize) usize {
    return @max(a -| b, b -| a);
}

export fn absdiff4(a: usize, b: usize) usize {
    return @min(a -% b, b -% a);
}
// Only works for numbers with known size. 
// From mentioned versions it is the only one which uses `a` and `b` expressions once so it is theoretically usable as inline expression.
export fn absdiff5(a: u32, b: u32) u32 {
    return @intCast(@abs(@as(i33, a) - @as(i33, b)));
}

const builtin = @import("builtin");
export fn absdiff_asm(a: usize, b: usize) usize {
    switch (builtin.cpu.arch) {
        .aarch64 => {
            return asm volatile (
                \\ subs x0, x0, x1
                \\ cneg x0, x0, cc
                : [ret] "={x0}" (-> usize),
                : [inp_a] "{x0}" (a),
                  [inp_b] "{x1}" (b),
                : .{ .nzcv = true });
        },
        .arm => {
            return asm volatile (
                \\ subs r0, r0, r1
                \\ rsbcc r0, r0, #0
                : [ret] "={r0}" (-> usize),
                : [inp_a] "{r0}" (a),
                  [inp_b] "{r1}" (b),
                : .{ .apsr = true });
        },
        .x86_64 => {
            // mov     rax, rsi
            // sub     rax, rdi
            // sub     rdi, rsi
            // cmovae  rax, rdi
            return asm volatile (
                \\ movq %%rsi, %%rax
                \\ subq %%rdi, %%rax
                \\ subq %%rsi, %%rdi
                \\ cmovae %%rdi, %%rax
                : [ret] "={rax}" (-> usize),
                : [inp_a] "{rdi}" (a),
                  [inp_b] "{rsi}" (b),
                : .{ .cc = true });
        },
        .x86 => {
            // ecx = a - b
            // eax = b - a
            // mov     ecx, dword ptr [ebp + 8]
            // mov     eax, dword ptr [ebp + 12]
            // sub     eax, dword ptr [ebp + 8]
            // sub     ecx, dword ptr [ebp + 12]
            // cmovb   eax, ecx
            return asm volatile (
                \\ mov 8(%%ebp), %%ecx
                \\ mov 12(%%ebp), %%eax
                \\ sub 8(%%ebp), %%eax
                \\ sub 12(%%ebp), %%ecx
                \\ cmovc %%ecx, %[ret]
                : [ret] "={eax}" (-> usize),
                :
                : .{ .cc = true, .ecx = true });
        },
        else => @compileError("TODO: add support for arch: " ++ @tagName(builtin.cpu.arch)),
    }
}