// vtest build: !msvc
import v.slow_tests.assembly.util

fn test_inline_asm() {
    a, mut b := i64(10), i64(0)
    asm amd64 {
        mov rax, a
        mov b, rax
        ; +r (b)
        ; r (a)
        ; rax
    }
    assert a == 10
    assert b == 10

    mut c := 0
    asm amd64 {
        mov c, 5
        ; +r (c)
    }
    assert c == 5

    d, e, mut f := 10, 2, 0
    asm amd64 {
        mov f, d
        add f, e
        add f, 5
        ; +r (f) // output
        ; r (d)
          r (e) // input
    }
    assert d == 10
    assert e == 2
    assert f == 17

    // g, h, i := 2.3, 4.8, -3.5
    // asm rv64 {
    //     fadd.s ${i}, ${g}, ${h} // test `.` in instruction name
    //     : =r (i) as i
    //     : r (g) as g
    //       r (g) as h
    // }
    // assert g == 2.3
    // assert h == 4.8
    // assert i == 7.1

    mut j := 0
    // do 5*3
    // adding three, five times
    asm amd64 {
        mov rcx, 5 // loop 5 times
        loop_start:
        add j, 3
        loop loop_start
        ; +r (j)
        ; ; rcx
    }
    assert j == 5 * 3

    // k := 0 // Wait for tcc to implement goto, and gcc has odd errors
    // mut loops := 0
    // outside_label:
    // if k != 5 {
    //     loops++
    //     asm goto amd64 {
    //         mov k, 1
    //         mov k, 5
    //         jmp outside_label
    //         ; =r (k) as k
    //         ; r (k)
    //         ;
    //         ; outside_label
    //     }
    // }
    // assert loops == 1
    // assert k == 5

    // not marked as mut because we dereference m to change l
    l := 5
    m := &l
    asm amd64 {
        movq [m], 7 // have to specify size with q
        ; ; r (m)
        ; memory
    }
    assert l == 7

    // same as above
    n := [5, 9, 0, 4]
    asm amd64 {
        loop_start2:
        addq [in_data + rcx * 4 + 0], 2
        loop loop_start2
        addq [in_data + rcx * 4 + 0], 2
        ; ; c (n.len - 1) // c is counter (loop) register
          r (n.data) as in_data
        ; memory
    }
    assert n == [7, 11, 2, 6]

    assert util.add(8, 9, 34, 7) == 58 // test .amd64.v imported files

    mut o := &Manu{}
    asm amd64 {
        mov eax, 0
        cpuid
        ; =b (o.ebx) as ebx0
          =d (o.edx) as edx0
          =c (o.ecx) as ecx0
        ; ; eax
    }
    assert o.str()[0].is_capital()
}

@[packed]
struct Manu {
mut:
    ebx  u32
    edx  u32
    ecx  u32
    zero u8 // for string
}

fn (m &Manu) str() string {
    return unsafe {
        string{
            str:    &u8(m)
            len:    12
            is_lit: 1
        }
    }
}

// this test does not appear in i386 test since rip relative addressing was introduced in 64-bit mode
// doesn't actually work
@[if !macos]
fn test_rip_relative_label() {
    $if !macos {
        mut a := i64(4)
        asm amd64 {
            mov a, [rip + one_two_three] // see below
            ; =r (a)
        }
        assert a == 48321074923
    }
}

$if !macos {
    asm amd64 {
        .global one_two_three
        one_two_three:
        .quad 48321074923
    }
}

// this test does not appear in i386 test since rip relative addressing was introduced in 64-bit mode
// doesn't actually work
@[if !macos]
fn test_rip_relative_label_u8() {
    $if !macos {
        mut a := int(4)
        asm amd64 {
            mov a, [rip + byte_sequence] // see below
            ; =r (a)
        }
        assert a == 0x480f3527
    }
}

$if !macos {
    asm amd64 {
        .global byte_sequence
        byte_sequence:
        .byte 0x27, 0x35, 0x0f, 0x48
    }
}

fn test_asm_generic() {
    u := u64(49)
    assert generic_asm(u) == 14
    assert u == 63

    i := i32(123)
    assert generic_asm(i) == 14
    assert i == 137
}

fn generic_asm[T](var &T) T {
    mut ret := T(14)
    unsafe {
        asm volatile amd64 {
            add var, ret
            ; +m (var[0]) as var
              +r (ret)
            ; ; memory
        }
    }
    return ret
}

fn test_lock_prefix() {
    mut rv := u64(123)
    mut atom := u64(0)
    cmp := u64(1)
    xchg := u64(1)

    asm amd64 {
        lock cmpxchgq '%1', '%2'
        ; =a (rv)
          +m (atom)
        ; q (xchg)
          0 (cmp)
        ; memory
    }
    assert rv == 0
    assert atom == 0
}