//! 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] = undefined;

static ASM_TEXT_STORAGE: [u32; 256] = undefined;

static ASM_DATA_STORAGE: [u8; 1024] = undefined;

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

static PRINT_ARENA_STORAGE: [u8; 1024] = undefined;

static PRINT_BUFFER: [u8; 128] = undefined;

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;

    };

}

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;

}

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 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 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 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 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));

}

/// Verbose source must fit an arena sized for its small assembled program.

@test fn testAssembleLongCommentWithBoundedSymbolStorage() throws (testing::TestError) {

    let mut source: [u8; 8192] = ['x'; 8192];

    set source[0] = '/';

    set source[1] = '/';

    let body = "\n.text; j @\"local::destination\"; @\"local::destination\" ret;";

    let _copied = try! mem::copy(&mut source[8192 - body.len..], body);

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

    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));

}

/// Fence encodings must order device I/O and synchronize instruction fetches.

@test fn testAssembleMachineFences() throws (testing::TestError) {

    let program = try assembleSource(".text; fence; fence.i;");

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

    try testing::expect(program.text[0] == 0x0ff0000f);

    try testing::expect(program.text[1] == 0x0000100f);

    try expectAssembleFail(".text; fence.i %a0;");

    try expectAssembleFail(".text; fence.x;");

}

@test 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 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 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 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 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 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 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 fn testAssembleAtomicOperationsAndWidths() throws (testing::TestError) {

    let sources: [*[u8]; 22] = [

        "lr.w %t0 0(%t2);",

        "lr.d %t0 0(%t2);",

        "sc.w %t0 %t1 0(%t2);",

        "sc.d %t0 %t1 0(%t2);",

        "amoswap.w %t0 %t1 0(%t2);",

        "amoswap.d %t0 %t1 0(%t2);",

        "amoadd.w %t0 %t1 0(%t2);",

        "amoadd.d %t0 %t1 0(%t2);",

        "amoxor.w %t0 %t1 0(%t2);",

        "amoxor.d %t0 %t1 0(%t2);",

        "amoand.w %t0 %t1 0(%t2);",

        "amoand.d %t0 %t1 0(%t2);",

        "amoor.w %t0 %t1 0(%t2);",

        "amoor.d %t0 %t1 0(%t2);",

        "amomin.w %t0 %t1 0(%t2);",

        "amomin.d %t0 %t1 0(%t2);",

        "amomax.w %t0 %t1 0(%t2);",

        "amomax.d %t0 %t1 0(%t2);",

        "amominu.w %t0 %t1 0(%t2);",

        "amominu.d %t0 %t1 0(%t2);",

        "amomaxu.w %t0 %t1 0(%t2);",

        "amomaxu.d %t0 %t1 0(%t2);",

    ];

    // Fixed ISA words keep encoder bugs visible instead of sharing its formula.

    let expected: [u32; 22] = [

        0x1003a2af, 0x1003b2af,

        0x1863a2af, 0x1863b2af,

        0x0863a2af, 0x0863b2af,

        0x0063a2af, 0x0063b2af,

        0x2063a2af, 0x2063b2af,

        0x6063a2af, 0x6063b2af,

        0x4063a2af, 0x4063b2af,

        0x8063a2af, 0x8063b2af,

        0xa063a2af, 0xa063b2af,

        0xc063a2af, 0xc063b2af,

        0xe063a2af, 0xe063b2af,

    ];

    for i in 0..sources.len {

        let program = try assembleSource(sources[i]);

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

        try testing::expect(program.text[0] == expected[i]);

    }

}

@test fn testAssembleAtomicOrderingAndRegisterFields() throws (testing::TestError) {

    let sources: [*[u8]; 5] = [

        "amoswap.w.aq %t0 %t1 0(%t2);",

        "amoswap.d.rl %t0 %t1 0(%t2);",

        "amoswap.d.aqrl %t0 %t1 0(%t2);",

        "lr.w.aqrl %t6 (%ra);",

        "sc.d.aq %zero %t6 (%t5);",

    ];

    let expected: [u32; 5] = [

        0x0c63a2af, 0x0a63b2af, 0x0e63b2af, 0x1600afaf, 0x1dff302f,

    ];

    for i in 0..sources.len {

        let program = try assembleSource(sources[i]);

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

        try testing::expect(program.text[0] == expected[i]);

    }

}

@test fn testAssembleInvalidAtomicOperandsFail() throws (testing::TestError) {

    try expectAssembleFail("lr.w %t0 %t1 0(%t2);");

    try expectAssembleFail("lr.d %t0;");

    try expectAssembleFail("sc.w %t0 0(%t2);");

    try expectAssembleFail("sc.d %t0 %t1 0(%t2) %t3;");

    try expectAssembleFail("amoadd.d %t0 %t1;");

    try expectAssembleFail("amoswap.w %t0 %t1 %t2;");

    try expectAssembleFail("lr.w %t0 1(%t2);");

    try expectAssembleFail("sc.d %t0 %t1 -1(%t2);");

    try expectAssembleFail("amoadd.w %t0 %t1 4294967296(%t2);");

}

@test fn testAssembleInvalidAtomicSuffixesFail() throws (testing::TestError) {

    try expectAssembleFail("lr %t0 0(%t2);");

    try expectAssembleFail("lr.b %t0 0(%t2);");

    try expectAssembleFail("sc.q %t0 %t1 0(%t2);");

    try expectAssembleFail("amoadd.wu %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap.aq.w %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap.w.rlaq %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap.w.aq.rl %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap.w.aq.aq %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap .w %t0 %t1 0(%t2);");

    try expectAssembleFail("amoswap.w .aq %t0 %t1 0(%t2);");

    try expectAssembleFail("add.w.aq %t0 %t1 %t2;");

}

@test 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"));

}