tests/test-progs/insttest/src/riscv/rv64i.cpp - amd/gem5 - Git at Google


            
            /*

            
             * Copyright (c) 2016 The University of Virginia

            
             * All rights reserved.

            
             *

            
             * Redistribution and use in source and binary forms, with or without

            
             * modification, are permitted provided that the following conditions are

            
             * met: redistributions of source code must retain the above copyright

            
             * notice, this list of conditions and the following disclaimer;

            
             * redistributions in binary form must reproduce the above copyright

            
             * notice, this list of conditions and the following disclaimer in the

            
             * documentation and/or other materials provided with the distribution;

            
             * neither the name of the copyright holders nor the names of its

            
             * contributors may be used to endorse or promote products derived from

            
             * this software without specific prior written permission.

            
             *

            
             * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

            
             * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

            
             * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

            
             * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

            
             * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

            
             * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

            
             * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

            
             * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

            
             * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

            
             * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

            
             * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

            
             *

            
             * Authors: Alec Roelke

            
             */


            #include <fcntl.h>

            
            #include <sys/stat.h>

            
            #include <sys/time.h>

            
            #include <sys/times.h>

            
            #include <sys/types.h>

            
            #include <unistd.h>


            #include <cstdint>

            
            #include <cstring>

            
            #include <iostream>

            
            #include <limits>


            #include "insttest.h"

            
            #include "rv64i.h"


            int main()

            
            {

            
                using namespace std;

            
                using namespace insttest;


                // LUI

            
                expect<int64_t>(4096, []{return I::lui(1);}, "lui");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::lui(0x80000);}, "lui, negative");


                // AUIPC

            
                expect<bool>(true, []{return I::auipc(3);}, "auipc");


                // Jump (JAL, JALR)

            
                expect<bool>(true, []{return I::jal();}, "jal");

            
                expect<bool>(true, []{return I::jalr();}, "jalr");


                // BEQ

            
                expect<bool>(true, []{return I::beq(5, 5);}, "beq, equal");

            
                expect<bool>(false, []{return I::beq(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "beq, not equal");


                // BNE

            
                expect<bool>(false, []{return I::bne(5, 5);}, "bne, equal");

            
                expect<bool>(true, []{return I::bne(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "bne, not equal");


                // BLT

            
                expect<bool>(true, []{return I::blt(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::max());}, "blt, less");

            
                expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::min());}, "blt, equal");

            
                expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "blt, greater");


                // BGE

            
                expect<bool>(false, []{return I::bge(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::max());}, "bge, less");

            
                expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::min());}, "bge, equal");

            
                expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "bge, greater");


                // BLTU

            
                expect<bool>(true, []{return I::blt(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::max());}, "bltu, greater");

            
                expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::min());}, "bltu, equal");

            
                expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "bltu, less");


                // BGEU

            
                expect<bool>(false, []{return I::bge(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::max());}, "bgeu, greater");

            
                expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::min(),

            
                        numeric_limits<int64_t>::min());}, "bgeu, equal");

            
                expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::max(),

            
                        numeric_limits<int64_t>::min());}, "bgeu, less");


                // Load (LB, LH, LW, LBU, LHU)

            
                expect<int64_t>(7, []{return I::load<int8_t, int64_t>(0x07);},

            
                        "lb, positive");

            
                expect<int64_t>(numeric_limits<int8_t>::min(),

            
                        []{return I::load<int8_t, int64_t>(0x80);}, "lb, negative");

            
                expect<int64_t>(1792, []{return I::load<int16_t, int64_t>(0x0700);},

            
                        "lh, positive");

            
                expect<int64_t>(numeric_limits<int16_t>::min(),

            
                        []{return I::load<int16_t, int64_t>(0x8000);}, "lh, negative");

            
                expect<int64_t>(458752, []{return I::load<int32_t, int64_t>(0x00070000);},

            
                        "lw, positive");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::load<int32_t, int64_t>(0x80000000);},

            
                        "lw, negative");

            
                expect<uint64_t>(128, []{return I::load<uint8_t, uint64_t>(0x80);}, "lbu");

            
                expect<uint64_t>(32768, []{return I::load<uint16_t, uint64_t>(0x8000);},

            
                        "lhu");


                // Store (SB, SH, SW)

            
                expect<uint8_t>(0xFF, []{return I::store<int8_t>(-1);}, "sb");

            
                expect<uint16_t>(0xFFFF, []{return I::store<int16_t>(-1);}, "sh");

            
                expect<uint32_t>(0xFFFFFFFF, []{return I::store<int32_t>(-1);}, "sw");


                // ADDI

            
                expect<int64_t>(1073742078, []{return I::addi(0x3FFFFFFF, 255);},

            
                        "addi");

            
                expect<int64_t>(1, []{return I::addi(-1, 2);}, "addi, overflow");


                // SLTI

            
                expect<bool>(true, []{return I::slti(-1, 0);}, "slti, true");

            
                expect<bool>(false, []{return I::slti(0, -1);}, "slti, false");


                // SLTIU

            
                expect<bool>(false, []{return I::sltiu(-1, 0);}, "sltiu, false");

            
                expect<bool>(true, []{return I::sltiu(0, -1);}, "sltiu, true");

            
                expect<bool>(true, []{return I::sltiu(0xFFFF, -1);}, "sltiu, sext");


                // XORI

            
                expect<uint64_t>(0xFF, []{return I::xori(0xAA, 0x55);}, "xori (1)");

            
                expect<uint64_t>(0, []{return I::xori(0xAA, 0xAA);}, "xori (0)");


                // ORI

            
                expect<uint64_t>(0xFF, []{return I::ori(0xAA, 0x55);}, "ori (1)");

            
                expect<uint64_t>(0xAA, []{return I::ori(0xAA, 0xAA);}, "ori (A)");


                // ANDI

            
                expect<uint64_t>(0, []{return I::andi(-1, 0);}, "andi (0)");

            
                expect<uint64_t>(0x1234567812345678ULL,

            
                        []{return I::andi(0x1234567812345678ULL, -1);}, "andi (1)");


                // SLLI

            
                expect<int64_t>(65280, []{return I::slli(255, 8);}, "slli, general");

            
                expect<int64_t>(numeric_limits<int64_t>::min(),

            
                        []{return I::slli(255, 63);}, "slli, erase");


                // SRLI

            
                expect<int64_t>(255, []{return I::srli(65280, 8);}, "srli, general");

            
                expect<int64_t>(0, []{return I::srli(255, 8);}, "srli, erase");

            
                expect<int64_t>(1, []{return I::srli(numeric_limits<int64_t>::min(), 63);},

            
                        "srli, negative");


                // SRAI

            
                expect<int64_t>(255, []{return I::srai(65280, 8);}, "srai, general");

            
                expect<int64_t>(0, []{return I::srai(255, 8);}, "srai, erase");

            
                expect<int64_t>(-1,

            
                        []{return I::srai(numeric_limits<int64_t>::min(), 63);},

            
                        "srai, negative");


                // ADD

            
                expect<int64_t>(1073742078, []{return I::add(0x3FFFFFFF, 255);}, "add");

            
                expect<int64_t>(-1,

            
                        []{return I::add(0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL);},

            
                        "add, overflow");


                // SUB

            
                expect<int64_t>(65535, []{return I::sub(65536, 1);}, "sub");

            
                expect<int64_t>(-1,

            
                        []{return I::sub(0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL);},

            
                        "sub, \"overflow\"");


                // SLL

            
                expect<int64_t>(65280, []{return I::sll(255, 8);}, "sll, general");

            
                expect<int64_t>(numeric_limits<int64_t>::min(),

            
                        []{return I::sll(255, 63);}, "sll, erase");


                // SLT

            
                expect<bool>(true, []{return I::slt(-1, 0);}, "slt, true");

            
                expect<bool>(false, []{return I::slt(0, -1);}, "slt, false");


                // SLTU

            
                expect<bool>(false, []{return I::sltu(-1, 0);}, "sltu, false");

            
                expect<bool>(true, []{return I::sltu(0, -1);}, "sltu, true");


                // XOR

            
                expect<uint64_t>(-1,

            
                        []{return I::xor_inst(0xAAAAAAAAAAAAAAAAULL,

            
                                0x5555555555555555ULL);},

            
                        "xor (1)");

            
                expect<uint64_t>(0,

            
                        []{return I::xor_inst(0xAAAAAAAAAAAAAAAAULL,

            
                                0xAAAAAAAAAAAAAAAAULL);},

            
                        "xor (0)");


                // SRL

            
                expect<uint64_t>(255, []{return I::srl(65280, 8);}, "srl, general");

            
                expect<uint64_t>(0, []{return I::srl(255, 8);}, "srl, erase");

            
                expect<uint64_t>(1, []{return I::srl(numeric_limits<int64_t>::min(), 63);},

            
                        "srl, negative");


                // SRA

            
                expect<int64_t>(255, []{return I::sra(65280, 8);}, "sra, general");

            
                expect<int64_t>(0, []{return I::sra(255, 8);}, "sra, erase");

            
                expect<int64_t>(-1, []{return I::sra(numeric_limits<int64_t>::min(), 63);},

            
                        "sra, negative");


                // OR

            
                expect<uint64_t>(-1,

            
                        []{return I::or_inst(0xAAAAAAAAAAAAAAAAULL,

            
                                0x5555555555555555ULL);},

            
                        "or (1)");

            
                expect<uint64_t>(0xAAAAAAAAAAAAAAAAULL,

            
                        []{return I::or_inst(0xAAAAAAAAAAAAAAAAULL,

            
                                0xAAAAAAAAAAAAAAAAULL);},

            
                        "or (A)");


                // AND

            
                expect<uint64_t>(0, []{return I::and_inst(-1, 0);}, "and (0)");

            
                expect<uint64_t>(0x1234567812345678ULL,

            
                        []{return I::and_inst(0x1234567812345678ULL, -1);}, "and (-1)");


                // FENCE/FENCE.I

            
                asm volatile("fence" : : );

            
                asm volatile("fence.i" : : );


                // ECALL

            
                char fname[] = "test.txt";

            
                char teststr[] = "this is a test";

            
                expect<bool>(true, [=]{

            
                        int fd = open(fname, O_CREAT | O_WRONLY | O_TRUNC, 0644);

            
                        if (fd < 0) {

            
                            return false;

            
                        }

            
                        size_t n = write(fd, teststr, sizeof(teststr));

            
                        cout << "Bytes written: " << n << endl;

            
                        return close(fd) >= 0 && n > 0;

            
                    }, "open, write");

            
                expect<int>(0, [=]{return access(fname, F_OK);}, "access F_OK");

            
                expect<int>(0, [=]{return access(fname, R_OK);}, "access R_OK");

            
                expect<int>(0, [=]{return access(fname, W_OK);}, "access W_OK");

            
                // gem5's implementation of access is incorrect; it should return

            
                // -1 on failure, not -errno.  Account for this using an inequality.

            
                expect<bool>(true, [=]{return access(fname, X_OK) != 0;}, "access X_OK");

            
                expect<bool>(true, [=]{

            
                        struct stat stat_buf, fstat_buf;

            
                        int s = stat(fname, &stat_buf);

            
                        if (s < 0) {

            
                            return false;

            
                        } else {

            
                            cout << "stat:" << endl;

            
                            cout << "\tst_dev =\t" << stat_buf.st_dev << endl;

            
                            cout << "\tst_ino =\t" << stat_buf.st_ino << endl;

            
                            cout << "\tst_mode =\t" << stat_buf.st_mode << endl;

            
                            cout << "\tst_nlink =\t" << stat_buf.st_nlink << endl;

            
                            cout << "\tst_uid =\t" << stat_buf.st_uid << endl;

            
                            cout << "\tst_gid =\t" << stat_buf.st_gid << endl;

            
                            cout << "\tst_rdev =\t" << stat_buf.st_rdev << endl;

            
                            cout << "\tst_size =\t" << stat_buf.st_size << endl;

            
                            cout << "\tst_blksize =\t" << stat_buf.st_blksize << endl;

            
                            cout << "\tst_blocks =\t" << stat_buf.st_blocks << endl;

            
                        }

            
                        int fd = open(fname, O_RDONLY);

            
                        if (fd < 0) {

            
                            return false;

            
                        }

            
                        int f = fstat(fd, &fstat_buf);

            
                        if (f >= 0) {

            
                            cout << "fstat:" << endl;

            
                            cout << "\tst_dev =\t" << fstat_buf.st_dev << endl;

            
                            cout << "\tst_ino =\t" << fstat_buf.st_ino << endl;

            
                            cout << "\tst_mode =\t" << fstat_buf.st_mode << endl;

            
                            cout << "\tst_nlink =\t" << fstat_buf.st_nlink << endl;

            
                            cout << "\tst_uid =\t" << fstat_buf.st_uid << endl;

            
                            cout << "\tst_gid =\t" << fstat_buf.st_gid << endl;

            
                            cout << "\tst_rdev =\t" << fstat_buf.st_rdev << endl;

            
                            cout << "\tst_size =\t" << fstat_buf.st_size << endl;

            
                            cout << "\tst_blksize =\t" << fstat_buf.st_blksize << endl;

            
                            cout << "\tst_blocks =\t" << fstat_buf.st_blocks << endl;

            
                        }

            
                        return close(fd) >= 0 && f >= 0;

            
                    }, "open, stat");

            
                expect<bool>(true, [=]{

            
                        int fd = open(fname, O_RDONLY);

            
                        if (fd < 0) {

            
                            return false;

            
                        }

            
                        char in[128];

            
                        size_t n = read(fd, in, sizeof(in));

            
                        cout << "Bytes read: " << n << endl;

            
                        cout << "String read: " << in << endl;

            
                        int cl = close(fd);

            
                        int un = unlink(fname);

            
                        return n > 0 && cl >= 0 && un >= 0 && strcmp(teststr, in) == 0;

            
                    }, "open, read, unlink");

            
                expect<bool>(true, []{

            
                        struct tms buf;

            
                        clock_t t = times(&buf);

            
                        cout << "times:" << endl;

            
                        cout << "\ttms_utime =\t" << buf.tms_utime << endl;

            
                        cout << "\ttms_stime =\t" << buf.tms_stime << endl;

            
                        cout << "\ttms_cutime =\t" << buf.tms_cutime << endl;

            
                        cout << "\ttms_cstime =\t" << buf.tms_cstime << endl;

            
                        return t > 0;

            
                    }, "times");

            
                expect<int>(0, []{

            
                        struct timeval time;

            
                        int res = gettimeofday(&time, nullptr);

            
                        cout << "timeval:" << endl;

            
                        cout << "\ttv_sec =\t" << time.tv_sec << endl;

            
                        cout << "\ttv_usec =\t" << time.tv_usec << endl;

            
                        return res;

            
                    }, "gettimeofday");


                // EBREAK not tested because it only makes sense in FS mode or when

            
                // using gdb


                // ERET not tested because it only makes sense in FS mode and will cause

            
                // a panic when used in SE mode


                // CSRs (RDCYCLE, RDTIME, RDINSTRET)

            
                expect<bool>(true, []{

            
                            uint64_t cycles = 0;

            
                            asm("rdcycle %0" : "=r" (cycles));

            
                            cout << "Cycles: " << cycles << endl;

            
                            return cycles > 0;

            
                        }, "rdcycle");

            
                expect<bool>(true, []{

            
                            uint64_t time = 0;

            
                            asm("rdtime %0" : "=r" (time));

            
                            cout << "Time: " << time << endl;

            
                            return time > 0;

            
                        }, "rdtime");

            
                expect<bool>(true, []{

            
                            uint64_t instret = 0;

            
                            asm("rdinstret %0" : "=r" (instret));

            
                            cout << "Instructions Retired: " << instret << endl;

            
                            return instret > 0;

            
                        }, "rdinstret");


                // 64-bit memory (LWU, LD, SD)

            
                expect<int64_t>(0xFFFFFFFF, []{return I::load<uint32_t, uint64_t>(-1);},

            
                        "lwu");

            
                expect<int64_t>(30064771072,

            
                        []{return I::load<int64_t, int64_t>(30064771072);}, "ld");

            
                expect<uint64_t>(-1, []{return I::store<int64_t>(-1);}, "sd");


                // ADDIW

            
                expect<int64_t>(268435710, []{return I::addiw(0x0FFFFFFF, 255);}, "addiw");

            
                expect<int64_t>(-2147481602, []{return I::addiw(0x7FFFFFFF, 0x7FF);},

            
                        "addiw, overflow");

            
                expect<int64_t>(0, []{return I::addiw(0x7FFFFFFFFFFFFFFFLL, 1);},

            
                        "addiw, truncate");


                // SLLIW

            
                expect<int64_t>(65280, []{return I::slliw(255, 8);}, "slliw, general");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::slliw(255, 31);}, "slliw, erase");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::slliw(0xFFFFFFFF00800000LL, 8);}, "slliw, truncate");


                // SRLIW

            
                expect<int64_t>(255, []{return I::srliw(65280, 8);}, "srliw, general");

            
                expect<int64_t>(0, []{return I::srliw(255, 8);}, "srliw, erase");

            
                expect<int64_t>(1,

            
                        []{return I::srliw(numeric_limits<int32_t>::min(), 31);},

            
                        "srliw, negative");

            
                expect<int64_t>(1, []{return I::srliw(0xFFFFFFFF80000000LL, 31);},

            
                        "srliw, truncate");


                // SRAIW

            
                expect<int64_t>(255, []{return I::sraiw(65280, 8);}, "sraiw, general");

            
                expect<int64_t>(0, []{return I::sraiw(255, 8);}, "sraiw, erase");

            
                expect<int64_t>(-1,

            
                        []{return I::sraiw(numeric_limits<int32_t>::min(), 31);},

            
                        "sraiw, negative");

            
                expect<int64_t>(-1, []{return I::sraiw(0x0000000180000000LL, 31);},

            
                        "sraiw, truncate");


                // ADDW

            
                expect<int64_t>(1073742078, []{return I::addw(0x3FFFFFFF, 255);}, "addw");

            
                expect<int64_t>(-1, []{return I::addw(0x7FFFFFFF, 0x80000000);},

            
                        "addw, overflow");

            
                expect<int64_t>(65536, []{return I::addw(0xFFFFFFFF0000FFFFLL, 1);},

            
                        "addw, truncate");


                // SUBW

            
                expect<int64_t>(65535, []{return I::subw(65536, 1);}, "subw");

            
                expect<int64_t>(-1, []{return I::subw(0x7FFFFFFF, 0x80000000);},

            
                        "subw, \"overflow\"");

            
                expect<int64_t>(0,

            
                        []{return I::subw(0xAAAAAAAAFFFFFFFFULL, 0x55555555FFFFFFFFULL);},

            
                        "subw, truncate");


                // SLLW

            
                expect<int64_t>(65280, []{return I::sllw(255, 8);}, "sllw, general");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::sllw(255, 31);}, "sllw, erase");

            
                expect<int64_t>(numeric_limits<int32_t>::min(),

            
                        []{return I::sllw(0xFFFFFFFF00008000LL, 16);}, "sllw, truncate");


                // SRLW

            
                expect<uint64_t>(255, []{return I::srlw(65280, 8);}, "srlw, general");

            
                expect<uint64_t>(0, []{return I::srlw(255, 8);}, "srlw, erase");

            
                expect<uint64_t>(1,

            
                        []{return I::srlw(numeric_limits<int32_t>::min(), 31);},

            
                        "srlw, negative");

            
                expect<uint64_t>(1, []{return I::srlw(0x0000000180000000LL, 31);},

            
                        "srlw, truncate");


                // SRAW

            
                expect<int64_t>(255, []{return I::sraw(65280, 8);}, "sraw, general");

            
                expect<int64_t>(0, []{return I::sraw(255, 8);}, "sraw, erase");

            
                expect<int64_t>(-1,

            
                        []{return I::sraw(numeric_limits<int32_t>::min(), 31);},

            
                        "sraw, negative");

            
                expect<int64_t>(1, []{return I::sraw(0xFFFFFFFF40000000LL, 30);},

            
                        "sraw, truncate");


                return 0;

            
            }
	/*
	* Copyright (c) 2016 The University of Virginia
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met: redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer;
	* redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution;
	* neither the name of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* Authors: Alec Roelke
	*/

	#include <fcntl.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <sys/times.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <cstdint>
	#include <cstring>
	#include <iostream>
	#include <limits>

	#include "insttest.h"
	#include "rv64i.h"

	int main()
	{
	using namespace std;
	using namespace insttest;

	// LUI
	expect<int64_t>(4096, []{return I::lui(1);}, "lui");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::lui(0x80000);}, "lui, negative");

	// AUIPC
	expect<bool>(true, []{return I::auipc(3);}, "auipc");

	// Jump (JAL, JALR)
	expect<bool>(true, []{return I::jal();}, "jal");
	expect<bool>(true, []{return I::jalr();}, "jalr");

	// BEQ
	expect<bool>(true, []{return I::beq(5, 5);}, "beq, equal");
	expect<bool>(false, []{return I::beq(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "beq, not equal");

	// BNE
	expect<bool>(false, []{return I::bne(5, 5);}, "bne, equal");
	expect<bool>(true, []{return I::bne(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "bne, not equal");

	// BLT
	expect<bool>(true, []{return I::blt(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::max());}, "blt, less");
	expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::min());}, "blt, equal");
	expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "blt, greater");

	// BGE
	expect<bool>(false, []{return I::bge(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::max());}, "bge, less");
	expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::min());}, "bge, equal");
	expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "bge, greater");

	// BLTU
	expect<bool>(true, []{return I::blt(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::max());}, "bltu, greater");
	expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::min());}, "bltu, equal");
	expect<bool>(false, []{return I::blt(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "bltu, less");

	// BGEU
	expect<bool>(false, []{return I::bge(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::max());}, "bgeu, greater");
	expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::min(),
	numeric_limits<int64_t>::min());}, "bgeu, equal");
	expect<bool>(true, []{return I::bge(numeric_limits<int64_t>::max(),
	numeric_limits<int64_t>::min());}, "bgeu, less");

	// Load (LB, LH, LW, LBU, LHU)
	expect<int64_t>(7, []{return I::load<int8_t, int64_t>(0x07);},
	"lb, positive");
	expect<int64_t>(numeric_limits<int8_t>::min(),
	[]{return I::load<int8_t, int64_t>(0x80);}, "lb, negative");
	expect<int64_t>(1792, []{return I::load<int16_t, int64_t>(0x0700);},
	"lh, positive");
	expect<int64_t>(numeric_limits<int16_t>::min(),
	[]{return I::load<int16_t, int64_t>(0x8000);}, "lh, negative");
	expect<int64_t>(458752, []{return I::load<int32_t, int64_t>(0x00070000);},
	"lw, positive");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::load<int32_t, int64_t>(0x80000000);},
	"lw, negative");
	expect<uint64_t>(128, []{return I::load<uint8_t, uint64_t>(0x80);}, "lbu");
	expect<uint64_t>(32768, []{return I::load<uint16_t, uint64_t>(0x8000);},
	"lhu");

	// Store (SB, SH, SW)
	expect<uint8_t>(0xFF, []{return I::store<int8_t>(-1);}, "sb");
	expect<uint16_t>(0xFFFF, []{return I::store<int16_t>(-1);}, "sh");
	expect<uint32_t>(0xFFFFFFFF, []{return I::store<int32_t>(-1);}, "sw");

	// ADDI
	expect<int64_t>(1073742078, []{return I::addi(0x3FFFFFFF, 255);},
	"addi");
	expect<int64_t>(1, []{return I::addi(-1, 2);}, "addi, overflow");

	// SLTI
	expect<bool>(true, []{return I::slti(-1, 0);}, "slti, true");
	expect<bool>(false, []{return I::slti(0, -1);}, "slti, false");

	// SLTIU
	expect<bool>(false, []{return I::sltiu(-1, 0);}, "sltiu, false");
	expect<bool>(true, []{return I::sltiu(0, -1);}, "sltiu, true");
	expect<bool>(true, []{return I::sltiu(0xFFFF, -1);}, "sltiu, sext");

	// XORI
	expect<uint64_t>(0xFF, []{return I::xori(0xAA, 0x55);}, "xori (1)");
	expect<uint64_t>(0, []{return I::xori(0xAA, 0xAA);}, "xori (0)");

	// ORI
	expect<uint64_t>(0xFF, []{return I::ori(0xAA, 0x55);}, "ori (1)");
	expect<uint64_t>(0xAA, []{return I::ori(0xAA, 0xAA);}, "ori (A)");

	// ANDI
	expect<uint64_t>(0, []{return I::andi(-1, 0);}, "andi (0)");
	expect<uint64_t>(0x1234567812345678ULL,
	[]{return I::andi(0x1234567812345678ULL, -1);}, "andi (1)");

	// SLLI
	expect<int64_t>(65280, []{return I::slli(255, 8);}, "slli, general");
	expect<int64_t>(numeric_limits<int64_t>::min(),
	[]{return I::slli(255, 63);}, "slli, erase");

	// SRLI
	expect<int64_t>(255, []{return I::srli(65280, 8);}, "srli, general");
	expect<int64_t>(0, []{return I::srli(255, 8);}, "srli, erase");
	expect<int64_t>(1, []{return I::srli(numeric_limits<int64_t>::min(), 63);},
	"srli, negative");

	// SRAI
	expect<int64_t>(255, []{return I::srai(65280, 8);}, "srai, general");
	expect<int64_t>(0, []{return I::srai(255, 8);}, "srai, erase");
	expect<int64_t>(-1,
	[]{return I::srai(numeric_limits<int64_t>::min(), 63);},
	"srai, negative");

	// ADD
	expect<int64_t>(1073742078, []{return I::add(0x3FFFFFFF, 255);}, "add");
	expect<int64_t>(-1,
	[]{return I::add(0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL);},
	"add, overflow");

	// SUB
	expect<int64_t>(65535, []{return I::sub(65536, 1);}, "sub");
	expect<int64_t>(-1,
	[]{return I::sub(0x7FFFFFFFFFFFFFFFLL, 0x8000000000000000LL);},
	"sub, \"overflow\"");

	// SLL
	expect<int64_t>(65280, []{return I::sll(255, 8);}, "sll, general");
	expect<int64_t>(numeric_limits<int64_t>::min(),
	[]{return I::sll(255, 63);}, "sll, erase");

	// SLT
	expect<bool>(true, []{return I::slt(-1, 0);}, "slt, true");
	expect<bool>(false, []{return I::slt(0, -1);}, "slt, false");

	// SLTU
	expect<bool>(false, []{return I::sltu(-1, 0);}, "sltu, false");
	expect<bool>(true, []{return I::sltu(0, -1);}, "sltu, true");

	// XOR
	expect<uint64_t>(-1,
	[]{return I::xor_inst(0xAAAAAAAAAAAAAAAAULL,
	0x5555555555555555ULL);},
	"xor (1)");
	expect<uint64_t>(0,
	[]{return I::xor_inst(0xAAAAAAAAAAAAAAAAULL,
	0xAAAAAAAAAAAAAAAAULL);},
	"xor (0)");

	// SRL
	expect<uint64_t>(255, []{return I::srl(65280, 8);}, "srl, general");
	expect<uint64_t>(0, []{return I::srl(255, 8);}, "srl, erase");
	expect<uint64_t>(1, []{return I::srl(numeric_limits<int64_t>::min(), 63);},
	"srl, negative");

	// SRA
	expect<int64_t>(255, []{return I::sra(65280, 8);}, "sra, general");
	expect<int64_t>(0, []{return I::sra(255, 8);}, "sra, erase");
	expect<int64_t>(-1, []{return I::sra(numeric_limits<int64_t>::min(), 63);},
	"sra, negative");

	// OR
	expect<uint64_t>(-1,
	[]{return I::or_inst(0xAAAAAAAAAAAAAAAAULL,
	0x5555555555555555ULL);},
	"or (1)");
	expect<uint64_t>(0xAAAAAAAAAAAAAAAAULL,
	[]{return I::or_inst(0xAAAAAAAAAAAAAAAAULL,
	0xAAAAAAAAAAAAAAAAULL);},
	"or (A)");

	// AND
	expect<uint64_t>(0, []{return I::and_inst(-1, 0);}, "and (0)");
	expect<uint64_t>(0x1234567812345678ULL,
	[]{return I::and_inst(0x1234567812345678ULL, -1);}, "and (-1)");

	// FENCE/FENCE.I
	asm volatile("fence" : : );
	asm volatile("fence.i" : : );

	// ECALL
	char fname[] = "test.txt";
	char teststr[] = "this is a test";
	expect<bool>(true, [=]{
	int fd = open(fname, O_CREAT \| O_WRONLY \| O_TRUNC, 0644);
	if (fd < 0) {
	return false;
	}
	size_t n = write(fd, teststr, sizeof(teststr));
	cout << "Bytes written: " << n << endl;
	return close(fd) >= 0 && n > 0;
	}, "open, write");
	expect<int>(0, [=]{return access(fname, F_OK);}, "access F_OK");
	expect<int>(0, [=]{return access(fname, R_OK);}, "access R_OK");
	expect<int>(0, [=]{return access(fname, W_OK);}, "access W_OK");
	// gem5's implementation of access is incorrect; it should return
	// -1 on failure, not -errno. Account for this using an inequality.
	expect<bool>(true, [=]{return access(fname, X_OK) != 0;}, "access X_OK");
	expect<bool>(true, [=]{
	struct stat stat_buf, fstat_buf;
	int s = stat(fname, &stat_buf);
	if (s < 0) {
	return false;
	} else {
	cout << "stat:" << endl;
	cout << "\tst_dev =\t" << stat_buf.st_dev << endl;
	cout << "\tst_ino =\t" << stat_buf.st_ino << endl;
	cout << "\tst_mode =\t" << stat_buf.st_mode << endl;
	cout << "\tst_nlink =\t" << stat_buf.st_nlink << endl;
	cout << "\tst_uid =\t" << stat_buf.st_uid << endl;
	cout << "\tst_gid =\t" << stat_buf.st_gid << endl;
	cout << "\tst_rdev =\t" << stat_buf.st_rdev << endl;
	cout << "\tst_size =\t" << stat_buf.st_size << endl;
	cout << "\tst_blksize =\t" << stat_buf.st_blksize << endl;
	cout << "\tst_blocks =\t" << stat_buf.st_blocks << endl;
	}
	int fd = open(fname, O_RDONLY);
	if (fd < 0) {
	return false;
	}
	int f = fstat(fd, &fstat_buf);
	if (f >= 0) {
	cout << "fstat:" << endl;
	cout << "\tst_dev =\t" << fstat_buf.st_dev << endl;
	cout << "\tst_ino =\t" << fstat_buf.st_ino << endl;
	cout << "\tst_mode =\t" << fstat_buf.st_mode << endl;
	cout << "\tst_nlink =\t" << fstat_buf.st_nlink << endl;
	cout << "\tst_uid =\t" << fstat_buf.st_uid << endl;
	cout << "\tst_gid =\t" << fstat_buf.st_gid << endl;
	cout << "\tst_rdev =\t" << fstat_buf.st_rdev << endl;
	cout << "\tst_size =\t" << fstat_buf.st_size << endl;
	cout << "\tst_blksize =\t" << fstat_buf.st_blksize << endl;
	cout << "\tst_blocks =\t" << fstat_buf.st_blocks << endl;
	}
	return close(fd) >= 0 && f >= 0;
	}, "open, stat");
	expect<bool>(true, [=]{
	int fd = open(fname, O_RDONLY);
	if (fd < 0) {
	return false;
	}
	char in[128];
	size_t n = read(fd, in, sizeof(in));
	cout << "Bytes read: " << n << endl;
	cout << "String read: " << in << endl;
	int cl = close(fd);
	int un = unlink(fname);
	return n > 0 && cl >= 0 && un >= 0 && strcmp(teststr, in) == 0;
	}, "open, read, unlink");
	expect<bool>(true, []{
	struct tms buf;
	clock_t t = times(&buf);
	cout << "times:" << endl;
	cout << "\ttms_utime =\t" << buf.tms_utime << endl;
	cout << "\ttms_stime =\t" << buf.tms_stime << endl;
	cout << "\ttms_cutime =\t" << buf.tms_cutime << endl;
	cout << "\ttms_cstime =\t" << buf.tms_cstime << endl;
	return t > 0;
	}, "times");
	expect<int>(0, []{
	struct timeval time;
	int res = gettimeofday(&time, nullptr);
	cout << "timeval:" << endl;
	cout << "\ttv_sec =\t" << time.tv_sec << endl;
	cout << "\ttv_usec =\t" << time.tv_usec << endl;
	return res;
	}, "gettimeofday");

	// EBREAK not tested because it only makes sense in FS mode or when
	// using gdb

	// ERET not tested because it only makes sense in FS mode and will cause
	// a panic when used in SE mode

	// CSRs (RDCYCLE, RDTIME, RDINSTRET)
	expect<bool>(true, []{
	uint64_t cycles = 0;
	asm("rdcycle %0" : "=r" (cycles));
	cout << "Cycles: " << cycles << endl;
	return cycles > 0;
	}, "rdcycle");
	expect<bool>(true, []{
	uint64_t time = 0;
	asm("rdtime %0" : "=r" (time));
	cout << "Time: " << time << endl;
	return time > 0;
	}, "rdtime");
	expect<bool>(true, []{
	uint64_t instret = 0;
	asm("rdinstret %0" : "=r" (instret));
	cout << "Instructions Retired: " << instret << endl;
	return instret > 0;
	}, "rdinstret");

	// 64-bit memory (LWU, LD, SD)
	expect<int64_t>(0xFFFFFFFF, []{return I::load<uint32_t, uint64_t>(-1);},
	"lwu");
	expect<int64_t>(30064771072,
	[]{return I::load<int64_t, int64_t>(30064771072);}, "ld");
	expect<uint64_t>(-1, []{return I::store<int64_t>(-1);}, "sd");

	// ADDIW
	expect<int64_t>(268435710, []{return I::addiw(0x0FFFFFFF, 255);}, "addiw");
	expect<int64_t>(-2147481602, []{return I::addiw(0x7FFFFFFF, 0x7FF);},
	"addiw, overflow");
	expect<int64_t>(0, []{return I::addiw(0x7FFFFFFFFFFFFFFFLL, 1);},
	"addiw, truncate");

	// SLLIW
	expect<int64_t>(65280, []{return I::slliw(255, 8);}, "slliw, general");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::slliw(255, 31);}, "slliw, erase");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::slliw(0xFFFFFFFF00800000LL, 8);}, "slliw, truncate");

	// SRLIW
	expect<int64_t>(255, []{return I::srliw(65280, 8);}, "srliw, general");
	expect<int64_t>(0, []{return I::srliw(255, 8);}, "srliw, erase");
	expect<int64_t>(1,
	[]{return I::srliw(numeric_limits<int32_t>::min(), 31);},
	"srliw, negative");
	expect<int64_t>(1, []{return I::srliw(0xFFFFFFFF80000000LL, 31);},
	"srliw, truncate");

	// SRAIW
	expect<int64_t>(255, []{return I::sraiw(65280, 8);}, "sraiw, general");
	expect<int64_t>(0, []{return I::sraiw(255, 8);}, "sraiw, erase");
	expect<int64_t>(-1,
	[]{return I::sraiw(numeric_limits<int32_t>::min(), 31);},
	"sraiw, negative");
	expect<int64_t>(-1, []{return I::sraiw(0x0000000180000000LL, 31);},
	"sraiw, truncate");

	// ADDW
	expect<int64_t>(1073742078, []{return I::addw(0x3FFFFFFF, 255);}, "addw");
	expect<int64_t>(-1, []{return I::addw(0x7FFFFFFF, 0x80000000);},
	"addw, overflow");
	expect<int64_t>(65536, []{return I::addw(0xFFFFFFFF0000FFFFLL, 1);},
	"addw, truncate");

	// SUBW
	expect<int64_t>(65535, []{return I::subw(65536, 1);}, "subw");
	expect<int64_t>(-1, []{return I::subw(0x7FFFFFFF, 0x80000000);},
	"subw, \"overflow\"");
	expect<int64_t>(0,
	[]{return I::subw(0xAAAAAAAAFFFFFFFFULL, 0x55555555FFFFFFFFULL);},
	"subw, truncate");

	// SLLW
	expect<int64_t>(65280, []{return I::sllw(255, 8);}, "sllw, general");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::sllw(255, 31);}, "sllw, erase");
	expect<int64_t>(numeric_limits<int32_t>::min(),
	[]{return I::sllw(0xFFFFFFFF00008000LL, 16);}, "sllw, truncate");

	// SRLW
	expect<uint64_t>(255, []{return I::srlw(65280, 8);}, "srlw, general");
	expect<uint64_t>(0, []{return I::srlw(255, 8);}, "srlw, erase");
	expect<uint64_t>(1,
	[]{return I::srlw(numeric_limits<int32_t>::min(), 31);},
	"srlw, negative");
	expect<uint64_t>(1, []{return I::srlw(0x0000000180000000LL, 31);},
	"srlw, truncate");

	// SRAW
	expect<int64_t>(255, []{return I::sraw(65280, 8);}, "sraw, general");
	expect<int64_t>(0, []{return I::sraw(255, 8);}, "sraw, erase");
	expect<int64_t>(-1,
	[]{return I::sraw(numeric_limits<int32_t>::min(), 31);},
	"sraw, negative");
	expect<int64_t>(1, []{return I::sraw(0xFFFFFFFF40000000LL, 30);},
	"sraw, truncate");

	return 0;
	}