derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
13bc177e2db04e42f2a26ea5bbee2c035cf9279f
gem5/tests/test-progs/insttest/src/riscv/rv64i.cpp
Alec Roelke e228943538 arch-riscv: Make use of ImmOp's polymorphism 
This patch makes use of ImmOp's polymorphism to remove unnecessary
casting from the implementations of arithmetic instructions with
immediate operands and to remove the CUIOp format by combining it with
the CIOp format (compressed arithmetic instructions with immediate
operands). Interestingly, RISC-V specifies that instructions with
unsigned immediate operands still need to sign-extend the immediates
from 12 (or 20) bits to 64 bits, so that is left alone.

Change-Id: If20d70c1e90f379b9ed8a4155b2b9222b6defe16
Reviewed-on: https://gem5-review.googlesource.com/6401
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Reviewed-by: Tuan Ta <qtt2@cornell.edu>
Maintainer: Alec Roelke <ar4jc@virginia.edu>
2018-01-10 16:07:02 +00:00

434 lines
18 KiB
C++
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink