//! RV64 assembler tests.

use std::testing;

use std::mem;

use std::lang::alloc;

use std::lang::sexpr;

use std::lang::strings;

use std::arch::rv64;

use std::arch::rv64::encode;

use std::arch::rv64::printer;

use super::scanner;

static ASM_ARENA_STORAGE: [u8; 65536] = [0; 65536];

static ASM_TEXT_STORAGE: [u32; 256] = [0; 256];

static ASM_DATA_STORAGE: [u8; 1024] = [0; 1024];

unsafe static ASM_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

static PRINT_ARENA_STORAGE: [u8; 1024] = [0; 1024];

static PRINT_BUFFER: [u8; 128] = [0; 128];

/// The retired-instruction CSR assembles to its exact architectural encoding.

@test unsafe fn retiredCounter() throws (testing::TestError) {

    let program = try assembleSource(".text;\ncsrr %a0 instret;\n");

    assert program.text.len == 1 and program.text[0] == 0xc0202573;

}

/// Source buffer for comment capacity tests.

static SOURCE: [u8; 4096] = [0; 4096];

/// Long comments consume source space while leaving symbol and fixup demand small.

@test unsafe fn commentStorage() throws (testing::TestError) {

    let source = &mut SOURCE[..];

    for i in 0..source.len {

        set source[i] = 32;

    }

    set source[0] = '/'; set source[1] = '/';

    let text = "\n.text;\nret;\n";

    for byte, i in text {

        set source[source.len - text.len + i] = byte;

    }

    let program = try assembleSource(&SOURCE[..]);

    try testing::expect(program.text.len == 1 and program.text[0] == encode::ret());

}

unsafe fn assembleSource(source: *[u8]) -> super::Program throws (testing::TestError) {

    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);

    return try super::assemble(

        scanner::SourceKind::String,

        source,

        &mut ASM_TEXT_STORAGE[..],

        &mut ASM_DATA_STORAGE[..],

        &mut arena,

        &mut ASM_STRING_POOL,

        rv64::RO_DATA_BASE

    ) catch {

        throw testing::TestError::Failed;

    };

}

unsafe fn expectAssembleFail(source: *[u8]) throws (testing::TestError) {

    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);

    try super::assemble(

        scanner::SourceKind::String,

        source,

        &mut ASM_TEXT_STORAGE[..],

        &mut ASM_DATA_STORAGE[..],

        &mut arena,

        &mut ASM_STRING_POOL,

        rv64::RO_DATA_BASE

    ) catch {

        return;

    };

    throw testing::TestError::Failed;

}

unsafe fn printInstrText(instr: u32) -> *[u8] {

    let mut arena = alloc::new(&mut PRINT_ARENA_STORAGE[..]);

    let mut pos: u32 = 0;

    let mut out = sexpr::Output::Buffer { buf: &mut PRINT_BUFFER[..], pos: &mut pos };

    printer::printInstr(&mut out, &mut arena, instr);

    return &PRINT_BUFFER[..pos];

}

@test unsafe fn testAssemblePercentPrefixedRegisters() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\naddi %a0 %zero 42;\nsd %a0 8(%sp);\n"

    );

    try testing::expect(program.text.len == 2);

    try testing::expect(program.text[0] == encode::addi(rv64::A0, rv64::ZERO, 42));

    try testing::expect(program.text[1] == encode::sd(rv64::A0, rv64::SP, 8));

}

@test unsafe fn testAssembleDataAddressUsesRoDataBase() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\nla %t0 @value;\n.data;\n.byte 0;\n@value\n.byte 1;\n"

    );

    try testing::expect(program.text.len == 2);

    try testing::expect(program.text[0] == encode::lui(rv64::T0, 0x10));

    try testing::expect(program.text[1] == encode::addi(rv64::T0, rv64::T0, 1));

}

@test unsafe fn testAssembleTextAddressUsesPcRelative() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\nla %t0 @target;\n@target\nret;\n"

    );

    try testing::expect(program.text.len == 3);

    try testing::expect(program.text[0] == encode::auipc(rv64::T0, 0));

    try testing::expect(program.text[1] == encode::addi(rv64::T0, rv64::T0, 8));

}

@test unsafe fn testAssembleQuotedLabelNames() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\nj @\"foo.bar.baz\";\n@\"foo.bar.baz\"\nret;\n"

    );

    try testing::expect(program.text.len == 2);

    try testing::expect(program.text[0] == encode::jal(rv64::ZERO, 4));

    try testing::expect(program.text[1] == encode::jalr(rv64::ZERO, rv64::RA, 0));

}

@test unsafe fn testAssembleGlobalMarksOnlyDeclaredSymbols() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\n.export @exported;\n@local\nret;\n@exported\nret;\n@late\n.export @late;\nret;\n"

    );

    try testing::expect(program.symbols.len == 3);

    try testing::expect(not program.symbols[0].isExported);

    try testing::expect(program.symbols[1].isExported);

    try testing::expect(program.symbols[2].isExported);

}

@test unsafe fn testAssembleExternalTextFixups() throws (testing::TestError) {

    let program = try assembleSource(

        ".text;\ntail @\"::default\";\nla %t0 @\"::default\";\n"

    );

    try testing::expect(program.externalFixups.len == 2);

    let case super::FixupInfo::Jal { rd, index } = program.externalFixups[0].info else {

        throw testing::TestError::Failed;

    };

    try testing::expect(mem::eq(program.externalFixups[0].symbol, "::default"));

    try testing::expect(rd == rv64::ZERO);

    try testing::expect(index == 0);

    let case super::FixupInfo::Addr { rd: addrRd, index: addrIndex } = program.externalFixups[1].info else {

        throw testing::TestError::Failed;

    };

    try testing::expect(mem::eq(program.externalFixups[1].symbol, "::default"));

    try testing::expect(addrRd == rv64::T0);

    try testing::expect(addrIndex == 1);

}

@test unsafe fn testAssembleTextOverflow() throws (testing::TestError) {

    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);

    try super::assemble(

        scanner::SourceKind::String,

        ".text;\nret;\nret;\n",

        &mut ASM_TEXT_STORAGE[..1],

        &mut ASM_DATA_STORAGE[..1],

        &mut arena,

        &mut ASM_STRING_POOL,

        rv64::RO_DATA_BASE

    ) catch err {

        match err {

            case super::Error::TextOverflow => return,

            else => throw testing::TestError::Failed,

        }

    };

    throw testing::TestError::Failed;

}

@test unsafe fn testAssembleDataOverflow() throws (testing::TestError) {

    let mut arena = alloc::new(&mut ASM_ARENA_STORAGE[..]);

    try super::assemble(

        scanner::SourceKind::String,

        ".data;\n.byte 1, 2;\n",

        &mut ASM_TEXT_STORAGE[..1],

        &mut ASM_DATA_STORAGE[..1],

        &mut arena,

        &mut ASM_STRING_POOL,

        rv64::RO_DATA_BASE

    ) catch err {

        match err {

            case super::Error::DataOverflow => return,

            else => throw testing::TestError::Failed,

        }

    };

    throw testing::TestError::Failed;

}

@test unsafe fn testAssembleInvalidOperandsFail() throws (testing::TestError) {

    try expectAssembleFail(

        ".text;\nbeq %a0 %a1 @missing;\n"

    );

    try expectAssembleFail(

        ".text;\naddi a0 zero 1;\n"

    );

    try expectAssembleFail(

        ".text;\naddi % a0 %zero 1;\n"

    );

    try expectAssembleFail(

        ".text;\nli %a0 UNKNOWN;\n"

    );

    try expectAssembleFail(

        ".text;\n@start\nj start;\n"

    );

    try expectAssembleFail(

        ".data;\n.dword @missing;\n"

    );

}

@test unsafe fn testAssembleInvalidSyntaxFails() throws (testing::TestError) {

    try expectAssembleFail(

        ".text;\n@dup\n@dup\nret;\n"

    );

    try expectAssembleFail(

        ".text;\naddi %a0, %zero, 1\n"

    );

    try expectAssembleFail(

        ".constant PAGE, 4096;\n"

    );

    try expectAssembleFail(

        ".text;\naddi %a0, %zero, 1;\n"

    );

    try expectAssembleFail(

        ".export @kernel::main, @data::sym;\n"

    );

}

@test unsafe fn testAssembleInvalidSectionsFail() throws (testing::TestError) {

    try expectAssembleFail(

        ".data;\n.dword @target;\n.text;\n@target\nret;\n"

    );

    try expectAssembleFail(

        ".data;\naddi %a0 %zero 1;\n"

    );

    try expectAssembleFail(

        ".text;\n.byte 1;\n"

    );

    try expectAssembleFail(

        ".text;\n.word 1;\n"

    );

    try expectAssembleFail(

        ".text;\n.dword 1;\n"

    );

    try expectAssembleFail(

        ".text;\n.ascii \"x\";\n"

    );

    try expectAssembleFail(

        ".data;\n@value\n.byte 1;\n.text;\nj @value;\n"

    );

}

@test unsafe fn testAssembleInvalidDirectivesFail() throws (testing::TestError) {

    try expectAssembleFail(

        ".data;\n.ascii 'x';\n"

    );

    try expectAssembleFail(

        ".data;\n.byte 1 + 2;\n"

    );

    try expectAssembleFail(

        ".data;\n.byte 256;\n"

    );

    try expectAssembleFail(

        ".data;\n.word 2147483648;\n"

    );

    try expectAssembleFail(

        ".data;\n.space 4294967296;\n"

    );

    try expectAssembleFail(

        ".data;\n.align 3;\n"

    );

    try expectAssembleFail(

        ".text;\n.align 12;\n"

    );

    try expectAssembleFail(

        ".data;\n.align 4294967296;\n"

    );

}

@test unsafe fn testAssembleInvalidImmediateRangesFail() throws (testing::TestError) {

    try expectAssembleFail(

        ".text;\nslli %a0 %a1 64;\n"

    );

    try expectAssembleFail(

        ".text;\nslli %a0 %a1 4294967296;\n"

    );

    try expectAssembleFail(

        ".text;\nslliw %a0 %a1 2147483648;\n"

    );

    try expectAssembleFail(

        ".text;\ncsrsi mstatus 32;\n"

    );

}

@test unsafe fn testPrintInstrUsesPercentPrefixedRegisters() throws (testing::TestError) {

    let text = printInstrText(encode::addi(rv64::A0, rv64::SP, 42));

    try testing::expect(mem::eq(text, "addi    %a0, %sp, 42"));

}