github-mirrors/vortex
1
0
Fork 0
mirror of https://github.com/vortexgpgpu/vortex.git synced 2025-04-25 06:17:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
vortex/simX/instruction.cpp

2284 lines
80 KiB
C++
Raw Blame History

/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
*******************************************************************************/
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include "include/instruction.h"
#include "include/obj.h"
#include "include/core.h"
#include "include/harpfloat.h"
#include "include/debug.h"
#ifdef EMU_INSTRUMENTATION
#include "include/qsim-harp.h"
#endif
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
using namespace Harp;
using namespace std;
/* It is important that this stays consistent with the Harp::Instruction::Opcode
enum. */
ostream &Harp::operator<<(ostream &os, Instruction &inst) {
os << dec;
// if (inst.predicated) {
// os << "@p" << dec << inst.pred << " ? ";
// }
// os << inst.instTable[inst.op].opString << ' ';
// if (inst.rdestPresent) os << "%r" << dec << inst.rdest << ' ';
// if (inst.pdestPresent) os << "@p" << inst.pdest << ' ';
// for (int i = 0; i < inst.nRsrc; i++) {
// os << "%r" << dec << inst.rsrc[i] << ' ';
// }
// for (int i = 0; i < inst.nPsrc; i++) {
// os << "@p" << dec << inst.psrc[i] << ' ';
// }
// if (inst.immsrcPresent) {
// if (inst.refLiteral) os << inst.refLiteral->name;
// else os << "#0x" << hex << inst.immsrc;
// }
os << instTable[inst.op].opString;
return os;
}
bool checkUnanimous(unsigned p, const std::vector<std::vector<Reg<Word>>> &m,
const std::vector<bool> &tm) {
bool same;
unsigned i;
for (i = 0; i < m.size(); ++i) {
if (tm[i]) {
same = m[i][p];
break;
}
}
if (i == m.size())
throw DivergentBranchException();
//std::cout << "same: " << same << " with -> ";
for (; i < m.size(); ++i) {
if (tm[i]) {
//std::cout << " " << (bool(m[i][p]));
if (same != (bool(m[i][p]))) {
//std::cout << " FALSE\n";
return false;
}
}
}
//std::cout << " TRUE\n";
return true;
}
Word signExt(Word w, Size bit, Word mask) {
if (w >> (bit - 1))
w |= ~mask;
return w;
}
void upload(unsigned *addr, char *src, int size, Warp &c) {
// cerr << "WRITING FINAL: " << *src << " size: " << size << "\n";
unsigned current_addr = *addr;
c.core->mem.write(current_addr, size, c.supervisorMode, 4);
current_addr += 4;
for (int i = 0; i < size; i++) {
unsigned value = src[i] & 0x000000FF;
// cerr << "UPLOAD: (" << hex << current_addr << dec << ") = " << hex << ( value) << dec << "\n";
c.core->mem.write(current_addr, value, c.supervisorMode, 1);
current_addr += 1;
}
current_addr += (current_addr % 4);
*addr = current_addr;
}
void download(unsigned *addr, char *drain, Warp &c) {
unsigned current_addr = *addr;
int size;
size = c.core->mem.read(current_addr, c.supervisorMode);
current_addr += 4;
for (int i = 0; i < size; i++) {
unsigned read_word = c.core->mem.read(current_addr, c.supervisorMode);
char read_byte = (char)(read_word & 0x000000FF);
drain[i] = read_byte;
current_addr += 1;
}
current_addr += (current_addr % 4);
*addr = current_addr;
}
void downloadAlloc(unsigned *addr, char **drain_ptr, int &size, Warp &c) {
unsigned current_addr = *addr;
size = c.core->mem.read(current_addr, c.supervisorMode);
current_addr += 4;
(*drain_ptr) = (char *)malloc(size);
char *drain = *drain_ptr;
for (int i = 0; i < size; i++) {
unsigned read_word = c.core->mem.read(current_addr, c.supervisorMode);
char read_byte = (char)(read_word & 0x000000FF);
drain[i] = read_byte;
current_addr += 1;
}
*addr = current_addr;
}
#define CLOSE 1
#define ISATTY 2
#define LSEEK 3
#define READ 4
#define WRITE 5
#define FSTAT 6
#define OPEN 7
void trap_to_simulator(Warp &c) {
unsigned read_buffer = 0x71000000;
unsigned write_buffer = 0x72000000;
// cerr << "RAW READ BUFFER:\n";
// for (int i = 0; i < 10; i++)
// {
// unsigned new_addr = read_buffer + (4*i);
// unsigned data_read = c.core->mem.read(new_addr, c.supervisorMode);
// cerr << hex << new_addr << ": " << data_read << "\n";
// }
for (int j = 0; j < 1024; j += 1) {
c.core->mem.write((write_buffer + j), 0, c.supervisorMode, 1);
}
int command;
download(&read_buffer, (char *)&command, c);
// cerr << "Command: " << hex << command << dec << '\n';
switch (command) {
case (CLOSE): {
cerr << "trap_to_simulator: CLOSE not supported yet\n";
} break;
case (ISATTY): {
cerr << "trap_to_simulator: ISATTY not supported yet\n";
} break;
case (LSEEK): {
// cerr << "trap_to_simulator: LSEEK not supported yet\n";
int fd;
int offset;
int whence;
download(&read_buffer, (char *)&fd, c);
download(&read_buffer, (char *)&offset, c);
download(&read_buffer, (char *)&whence, c);
int retval = lseek(fd, offset, whence);
upload(&write_buffer, (char *)&retval, sizeof(int), c);
} break;
case (READ): {
// cerr << "trap_to_simulator: READ not supported yet\n";
int file;
unsigned ptr;
int len;
download(&read_buffer, (char *)&file, c);
download(&read_buffer, (char *)&ptr, c);
download(&read_buffer, (char *)&len, c);
char *buff = (char *)malloc(len);
int ret = read(file, buff, len);
for (int i = 0; i < len; i++) {
c.core->mem.write(ptr, buff[i], c.supervisorMode, 1);
ptr++;
}
// c.core->mem.write(ptr, 0, c.supervisorMode, 1);
free(buff);
} break;
case (WRITE): {
int file;
download(&read_buffer, (char *)&file, c);
file = (file == 1) ? 2 : file;
int size;
char *buf;
downloadAlloc(&read_buffer, &buf, size, c);
int e = write(file, buf, size);
free(buf);
} break;
case (FSTAT): {
cerr << "trap_to_simulator: FSTAT not supported yet\n";
int file;
download(&read_buffer, (char *)&file, c);
struct stat st;
fstat(file, &st);
fprintf(stderr, "------------------------\n");
fprintf(stderr, "Size of struct: %ld\n", sizeof(struct stat));
fprintf(stderr, "st_mode: %x\n", st.st_mode);
fprintf(stderr, "st_dev: %ld\n", st.st_dev);
fprintf(stderr, "st_ino: %ld\n", st.st_ino);
fprintf(stderr, "st_uid: %x\n", st.st_uid);
fprintf(stderr, "st_gid: %x\n", st.st_gid);
fprintf(stderr, "st_rdev: %ld\n", st.st_rdev);
fprintf(stderr, "st_size: %ld\n", st.st_size);
fprintf(stderr, "st_blksize: %ld\n", st.st_blksize);
fprintf(stderr, "st_blocks: %ld\n", st.st_blocks);
fprintf(stderr, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
upload(&write_buffer, (char *)&st.st_mode, sizeof(st.st_mode), c);
upload(&write_buffer, (char *)&st.st_dev, sizeof(st.st_dev), c);
// upload(&write_buffer, (char *) &st.st_uid , sizeof(st.st_uid), c);
// upload(&write_buffer, (char *) &st.st_gid , sizeof(st.st_gid), c);
// upload(&write_buffer, (char *) &st.st_size , sizeof(st.st_size), c);
// upload(&write_buffer, (char *) &st.st_blksize , sizeof(st.st_blksize), c);
// upload(&write_buffer, (char *) &st.st_blocks , sizeof(st.st_blocks), c);
// upload(&write_buffer, (char *) &st, sizeof(struct stat), c);
cerr << "RAW Write BUFFER:\n";
unsigned original_write_buffer = 0x72000000;
for (int i = 0; i < 10; i++) {
unsigned new_addr = original_write_buffer + (4 * i);
unsigned data_read = c.core->mem.read(new_addr, c.supervisorMode);
cerr << hex << new_addr << ": " << data_read << "\n";
}
} break;
case (OPEN): {
// cerr << "$$$$$$$$$$$$$$$$$$$$$$$$$ OPEN FROM simX\n";
unsigned name_ptr;
unsigned flags;
unsigned mode;
download(&read_buffer, (char *)&name_ptr, c);
download(&read_buffer, (char *)&flags, c);
download(&read_buffer, (char *)&mode, c);
char buffer[255];
unsigned read_word;
char read_byte;
int curr_ind = 0;
read_word = c.core->mem.read(name_ptr, c.supervisorMode);
read_byte = (char)(read_word & 0x000000FF);
while (read_byte != 0) {
buffer[curr_ind] = read_byte;
name_ptr++;
curr_ind++;
read_word = c.core->mem.read(name_ptr, c.supervisorMode);
read_byte = (char)(read_word & 0x000000FF);
}
buffer[curr_ind] = 0;
int fd = open(buffer, flags, mode);
// fprintf(stderr, "Name: --%s-- and fd: %d\n", buffer, fd);
upload(&write_buffer, (char *)&fd, sizeof(int), c);
} break;
default: {
cerr << "trap_to_simulator: DEFAULT not supported yet\n";
} break;
}
}
void Instruction::executeOn(Warp &c, trace_inst_t *trace_inst) {
/* If I try to execute a privileged instruction in user mode, throw an
exception 3. */
if (instTable[op].privileged && !c.supervisorMode) {
D(3, "INTERRUPT SUPERVISOR\n");
c.interrupt(3);
return;
}
bool is_vec = false;
Size nextActiveThreads = c.activeThreads;
Size wordSz = c.core->a.getWordSize();
Word nextPc = c.pc;
Word VLMAX;
c.memAccesses.clear();
unsigned real_pc = c.pc - 4;
if ((real_pc) == (0x70000000)) {
trap_to_simulator(c);
}
bool sjOnce(true), // Has not yet split or joined once.
pcSet(false); // PC has already been set
for (Size t = 0; t < c.activeThreads; t++) {
vector<Reg<Word>> &reg(c.reg[t]);
vector<Reg<bool>> &pReg(c.pred[t]);
stack<DomStackEntry> &domStack(c.domStack);
bool split = (op == GPGPU) && (func3 == 2);
bool join = (op == GPGPU) && (func3 == 3);
bool is_gpgpu = (op == GPGPU);
bool is_tmc = is_gpgpu && (func3 == 0);
bool is_wspawn = is_gpgpu && (func3 == 1);
bool is_barrier = is_gpgpu && (func3 == 4);
bool is_split = is_gpgpu && (func3 == 2);
bool is_join = is_gpgpu && (func3 == 3);
bool gpgpu_zero = (is_tmc || is_barrier || is_wspawn) && (t != 0);
bool not_active = !c.tmask[t];
if (not_active || gpgpu_zero) {
continue;
}
++c.insts;
Word memAddr;
Word shift_by;
Word shamt;
Word temp;
Word data_read;
int op1, op2;
bool m_exten;
// std::cout << "op = " << op << "\n";
// std::cout << "R_INST: " << R_INST << "\n";
int num_to_wspawn;
switch (op) {
case NOP:
//std::cout << "NOP_INST\n";
break;
case R_INST:
// std::cout << "R_INST\n";
m_exten = func7 & 0x1;
if (m_exten) {
// std::cout << "FOUND A MUL/DIV\n";
switch (func3) {
case 0:
// MUL
D(3, "MUL: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = ((int)reg[rsrc[0]]) * ((int)reg[rsrc[1]]);
break;
case 1:
// MULH
D(3, "MULH: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
{
int64_t first = (int64_t)reg[rsrc[0]];
if (reg[rsrc[0]] & 0x80000000) {
first = first | 0xFFFFFFFF00000000;
}
int64_t second = (int64_t)reg[rsrc[1]];
if (reg[rsrc[1]] & 0x80000000) {
second = second | 0xFFFFFFFF00000000;
}
// cout << "mulh: " << std::dec << first << " * " << second;
uint64_t result = first * second;
reg[rdest] = (result >> 32) & 0xFFFFFFFF;
// cout << " = " << result << " or " << reg[rdest] << "\n";
}
break;
case 2:
// MULHSU
D(3, "MULHSU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
{
int64_t first = (int64_t)reg[rsrc[0]];
if (reg[rsrc[0]] & 0x80000000) {
first = first | 0xFFFFFFFF00000000;
}
int64_t second = (int64_t)reg[rsrc[1]];
reg[rdest] = ((first * second) >> 32) & 0xFFFFFFFF;
}
break;
case 3:
// MULHU
D(3, "MULHU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
{
uint64_t first = (uint64_t)reg[rsrc[0]];
uint64_t second = (uint64_t)reg[rsrc[1]];
// cout << "MULHU\n";
reg[rdest] = ((first * second) >> 32) & 0xFFFFFFFF;
}
break;
case 4:
// DIV
D(3, "DIV: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (reg[rsrc[1]] == 0) {
reg[rdest] = -1;
break;
}
// cout << "dividing: " << dec << ((int) reg[rsrc[0]]) << " / " << ((int) reg[rsrc[1]]);
reg[rdest] = ((int)reg[rsrc[0]]) / ((int)reg[rsrc[1]]);
// cout << " = " << ((int) reg[rdest]) << "\n";
break;
case 5:
// DIVU
D(3, "DIVU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (reg[rsrc[1]] == 0) {
reg[rdest] = -1;
break;
}
reg[rdest] = ((uint32_t)reg[rsrc[0]]) / ((uint32_t)reg[rsrc[1]]);
break;
case 6:
// REM
D(3, "REM: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (reg[rsrc[1]] == 0) {
reg[rdest] = reg[rsrc[0]];
break;
}
reg[rdest] = ((int)reg[rsrc[0]]) % ((int)reg[rsrc[1]]);
break;
case 7:
// REMU
D(3, "REMU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (reg[rsrc[1]] == 0) {
reg[rdest] = reg[rsrc[0]];
break;
}
reg[rdest] = ((uint32_t)reg[rsrc[0]]) % ((uint32_t)reg[rsrc[1]]);
break;
default:
cout << "unsupported MUL/DIV instr\n";
std::abort();
}
} else {
// std::cout << "NORMAL R-TYPE\n";
switch (func3) {
case 0:
if (func7) {
D(3, "SUBI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] - reg[rsrc[1]];
reg[rdest].trunc(wordSz);
} else {
D(3, "ADDI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] + reg[rsrc[1]];
reg[rdest].trunc(wordSz);
}
break;
case 1:
D(3, "SLLI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] << reg[rsrc[1]];
reg[rdest].trunc(wordSz);
break;
case 2:
D(3, "SLTI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (int(reg[rsrc[0]]) < int(reg[rsrc[1]])) {
reg[rdest] = 1;
} else {
reg[rdest] = 0;
}
break;
case 3:
D(3, "SLTU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
if (Word_u(reg[rsrc[0]]) < Word_u(reg[rsrc[1]])) {
reg[rdest] = 1;
} else {
reg[rdest] = 0;
}
break;
case 4:
D(3, "XORI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] ^ reg[rsrc[1]];
break;
case 5:
if (func7) {
D(3, "SRLI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = int(reg[rsrc[0]]) >> int(reg[rsrc[1]]);
reg[rdest].trunc(wordSz);
} else {
D(3, "SRLU: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = Word_u(reg[rsrc[0]]) >> Word_u(reg[rsrc[1]]);
reg[rdest].trunc(wordSz);
}
break;
case 6:
D(3, "ORI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] | reg[rsrc[1]];
break;
case 7:
D(3, "ANDI: r" << rdest << " <- r" << rsrc[0] << ", r" << rsrc[1]);
reg[rdest] = reg[rsrc[0]] & reg[rsrc[1]];
break;
default:
cout << "ERROR: UNSUPPORTED R INST\n";
std::abort();
}
}
break;
case L_INST:
memAddr = ((reg[rsrc[0]] + immsrc) & 0xFFFFFFFC);
shift_by = ((reg[rsrc[0]] + immsrc) & 0x00000003) * 8;
data_read = c.core->mem.read(memAddr, c.supervisorMode);
trace_inst->is_lw = true;
trace_inst->mem_addresses[t] = memAddr;
switch (func3) {
case 0:
// LBI
D(3, "LBI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
reg[rdest] = signExt((data_read >> shift_by) & 0xFF, 8, 0xFF);
break;
case 1:
// LWI
D(3, "LWI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
reg[rdest] = signExt((data_read >> shift_by) & 0xFFFF, 16, 0xFFFF);
break;
case 2:
// LDI
D(3, "LDI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
reg[rdest] = int(data_read & 0xFFFFFFFF);
break;
case 4:
// LBU
D(3, "LBU: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
reg[rdest] = unsigned((data_read >> shift_by) & 0xFF);
break;
case 5:
// LWU
D(3, "LWU: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
reg[rdest] = unsigned((data_read >> shift_by) & 0xFFFF);
break;
default:
cout << "ERROR: UNSUPPORTED L INST\n";
std::abort();
c.memAccesses.push_back(Warp::MemAccess(false, memAddr));
}
D(3, "LOAD MEM ADDRESS: " << std::hex << memAddr);
D(3, "LOAD MEM DATA: " << std::hex << data_read);
break;
case I_INST:
//std::cout << "I_INST\n";
switch (func3) {
case 0:
// ADDI
D(3, "ADDI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << immsrc);
reg[rdest] = reg[rsrc[0]] + immsrc;
reg[rdest].trunc(wordSz);
break;
case 2:
// SLTI
D(3, "SLTI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << immsrc);
if (int(reg[rsrc[0]]) < int(immsrc)) {
reg[rdest] = 1;
} else {
reg[rdest] = 0;
}
break;
case 3:
// SLTIU
D(3, "SLTIU: r" << rdest << " <- r" << rsrc[0] << ", imm=" << immsrc);
op1 = (unsigned)reg[rsrc[0]];
if (unsigned(reg[rsrc[0]]) < unsigned(immsrc)) {
reg[rdest] = 1;
} else {
reg[rdest] = 0;
}
break;
case 4:
// XORI
D(3, "XORI: r" << rdest << " <- r" << rsrc[0] << ", imm=0x" << hex << immsrc);
reg[rdest] = reg[rsrc[0]] ^ immsrc;
break;
case 6:
// ORI
D(3, "ORI: r" << rdest << " <- r" << rsrc[0] << ", imm=0x" << hex << immsrc);
reg[rdest] = reg[rsrc[0]] | immsrc;
break;
case 7:
// ANDI
D(3, "ANDI: r" << rdest << " <- r" << rsrc[0] << ", imm=0x" << hex << immsrc);
reg[rdest] = reg[rsrc[0]] & immsrc;
break;
case 1:
// SLLI
D(3, "SLLI: r" << rdest << " <- r" << rsrc[0] << ", imm=0x" << hex << immsrc);
reg[rdest] = reg[rsrc[0]] << immsrc;
reg[rdest].trunc(wordSz);
break;
case 5:
if ((func7 == 0)) {
// SRLI
D(3, "SRLI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << immsrc);
bool isNeg = ((0x80000000 & reg[rsrc[0]])) > 0;
Word result = Word_u(reg[rsrc[0]]) >> Word_u(immsrc);
reg[rdest] = result;
reg[rdest].trunc(wordSz);
} else {
// SRAI
D(3, "SRAI: r" << rdest << " <- r" << rsrc[0] << ", imm=" << immsrc);
op1 = reg[rsrc[0]];
op2 = immsrc;
reg[rdest] = op1 >> op2;
reg[rdest].trunc(wordSz);
}
break;
default:
cout << "ERROR: UNSUPPORTED L INST\n";
std::abort();
}
break;
case S_INST:
++c.stores;
memAddr = reg[rsrc[0]] + immsrc;
trace_inst->is_sw = true;
trace_inst->mem_addresses[t] = memAddr;
// //std::cout << "FUNC3: " << func3 << "\n";
if ((memAddr == 0x00010000) && (t == 0)) {
unsigned num = reg[rsrc[1]];
fprintf(stderr, "%c", (char)reg[rsrc[1]]);
break;
}
switch (func3) {
case 0:
// SB
D(3, "SB: r" << rsrc[1] << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
c.core->mem.write(memAddr, reg[rsrc[1]] & 0x000000FF, c.supervisorMode, 1);
break;
case 1:
// SH
D(3, "SH: r" << rsrc[1] << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
c.core->mem.write(memAddr, reg[rsrc[1]], c.supervisorMode, 2);
break;
case 2:
// SD
D(3, "SD: r" << rsrc[1] << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
c.core->mem.write(memAddr, reg[rsrc[1]], c.supervisorMode, 4);
break;
default:
cout << "ERROR: UNSUPPORTED S INST\n";
std::abort();
}
D(3, "STORE MEM ADDRESS: " << std::hex << memAddr);
c.memAccesses.push_back(Warp::MemAccess(true, memAddr));
#ifdef EMU_INSTRUMENTATION
Harp::OSDomain::osDomain->do_mem(0, memAddr, c.core->mem.virtToPhys(memAddr), 8, true);
#endif
break;
case B_INST:
trace_inst->stall_warp = true;
switch (func3) {
case 0:
// BEQ
D(3, "BEQ: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (int(reg[rsrc[0]]) == int(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
case 1:
// BNE
D(3, "BNE: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (int(reg[rsrc[0]]) != int(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
case 4:
// BLT
D(3, "BLT: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (int(reg[rsrc[0]]) < int(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
case 5:
// BGE
D(3, "BGE: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (int(reg[rsrc[0]]) >= int(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
case 6:
// BLTU
D(3, "BLTU: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (Word_u(reg[rsrc[0]]) < Word_u(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
case 7:
// BGEU
D(3, "BGEU: r" << rsrc[0] << ", r" << rsrc[1] << ", imm=" << (int)immsrc);
if (Word_u(reg[rsrc[0]]) >= Word_u(reg[rsrc[1]])) {
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
pcSet = true;
}
break;
}
break;
case LUI_INST:
D(3, "LUI: r" << rdest << " <- imm=0x" << hex << immsrc);
reg[rdest] = (immsrc << 12) & 0xfffff000;
break;
case AUIPC_INST:
D(3, "AUIPC: r" << rdest << " <- imm=0x" << hex << immsrc);
reg[rdest] = ((immsrc << 12) & 0xfffff000) + (c.pc - 4);
break;
case JAL_INST:
D(3, "JAL: r" << rdest << " <- imm=" << (int)immsrc);
trace_inst->stall_warp = true;
if (!pcSet)
nextPc = (c.pc - 4) + immsrc;
if (!pcSet) { /*std::cout << "JAL... SETTING PC: " << nextPc << "\n"; */
}
if (rdest != 0) {
reg[rdest] = c.pc;
}
pcSet = true;
break;
case JALR_INST:
D(3, "JALR: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
trace_inst->stall_warp = true;
if (!pcSet)
nextPc = reg[rsrc[0]] + immsrc;
if (!pcSet) { /*std::cout << "JALR... SETTING PC: " << nextPc << "\n";*/
}
if (rdest != 0) {
reg[rdest] = c.pc;
}
pcSet = true;
break;
case SYS_INST:
D(3, "SYS_INST: r" << rdest << " <- r" << rsrc[0] << ", imm=" << (int)immsrc);
temp = reg[rsrc[0]];
// GPGPU CSR extension
if (immsrc == 0x20) {
// ThreadID
reg[rdest] = t;
D(3, "vx_threadID: r" << rdest << "=" << reg[rdest]);
} else if (immsrc == 0x21) {
// WarpID
reg[rdest] = c.id;
D(3, "vx_warpID: r" << rdest << "=" << reg[rdest]);
} else if (immsrc == 0x22) {
// WarpNum
reg[rdest] = c.id;
D(3, "vx_warpNum: r" << rdest << "=" << reg[rdest]);
} else if (immsrc == 0x25) {
// NumInsts
reg[rdest] = c.core->num_instructions;
D(3, "vx_getInst: r" << rdest << "=" << reg[rdest]);
} else if (immsrc == 0x26) {
// NumCycles
reg[rdest] = c.core->num_cycles;
D(3, "vx_getCycle: r" << rdest << "=" << reg[rdest]);
} else {
switch (func3) {
case 0:
if (immsrc < 2) {
//std::cout << "INTERRUPT ECALL/EBREAK\n";
nextActiveThreads = 0;
c.spawned = false;
// c.interrupt(0);
}
break;
case 1:
// printf("Case 1\n");
if (rdest != 0) {
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
c.csr[immsrc & 0x00000FFF] = temp;
break;
case 2:
// printf("Case 2\n");
if (rdest != 0) {
// printf("Reading from CSR: %d = %d\n", (immsrc & 0x00000FFF), c.csr[immsrc & 0x00000FFF]);
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
// printf("Writing to CSR --> %d = %d\n", immsrc, (temp | c.csr[immsrc & 0x00000FFF]));
c.csr[immsrc & 0x00000FFF] = temp | c.csr[immsrc & 0x00000FFF];
break;
case 3:
// printf("Case 3\n");
if (rdest != 0) {
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
c.csr[immsrc & 0x00000FFF] = temp & (~c.csr[immsrc & 0x00000FFF]);
break;
case 5:
// printf("Case 5\n");
if (rdest != 0) {
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
c.csr[immsrc & 0x00000FFF] = rsrc[0];
break;
case 6:
// printf("Case 6\n");
if (rdest != 0) {
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
c.csr[immsrc & 0x00000FFF] = rsrc[0] | c.csr[immsrc & 0x00000FFF];
break;
case 7:
// printf("Case 7\n");
if (rdest != 0) {
reg[rdest] = c.csr[immsrc & 0x00000FFF];
}
c.csr[immsrc & 0x00000FFF] = rsrc[0] & (~c.csr[immsrc & 0x00000FFF]);
break;
default:
break;
}
}
break;
case TRAP:
D(3, "TRAP");
nextActiveThreads = 0;
c.interrupt(0);
break;
case FENCE:
D(3, "FENCE");
break;
case PJ_INST:
D(3, "PJ_INST: r" << rsrc[0] << ", r" << rsrc[1]);
if (reg[rsrc[0]]) {
if (!pcSet)
nextPc = reg[rsrc[1]];
pcSet = true;
}
break;
case GPGPU:
switch (func3) {
case 1:
// WSPAWN
D(3, "WSPAWN: r" << rsrc[0] << ", r" << rsrc[1]);
trace_inst->wspawn = true;
if (sjOnce) {
sjOnce = false;
num_to_wspawn = std::min<unsigned>(reg[rsrc[0]], c.core->a.getNWarps());
D(0, "Spawning " << num_to_wspawn << " new warps at PC: " << hex << reg[rsrc[1]]);
for (unsigned i = 1; i < num_to_wspawn; ++i) {
Warp &newWarp(c.core->w[i]);
{
newWarp.pc = reg[rsrc[1]];
for (int kk = 0; kk < newWarp.tmask.size(); kk++) {
if (kk == 0) {
newWarp.tmask[kk] = true;
} else {
newWarp.tmask[kk] = false;
}
}
newWarp.activeThreads = 1;
newWarp.supervisorMode = false;
newWarp.spawned = true;
}
}
break;
}
break;
case 2: {
// SPLIT
D(3, "SPLIT: r" << pred);
trace_inst->stall_warp = true;
if (sjOnce) {
sjOnce = false;
if (checkUnanimous(pred, c.reg, c.tmask)) {
D(3, "Unanimous pred: " << pred << " val: " << reg[pred] << "\n");
DomStackEntry e(c.tmask);
e.uni = true;
c.domStack.push(e);
break;
}
D(3, "Split: Original TM: ");
for (auto y : c.tmask)
D(3, y << " ");
DomStackEntry e(pred, c.reg, c.tmask, c.pc);
c.domStack.push(c.tmask);
c.domStack.push(e);
for (unsigned i = 0; i < e.tmask.size(); ++i) {
c.tmask[i] = !e.tmask[i] && c.tmask[i];
}
D(3, "Split: New TM");
for (auto y : c.tmask)
D(3, y << " ");
D(3, "Split: Pushed TM PC: " << hex << e.pc << dec << "\n");
for (auto y : e.tmask)
D(3, y << " ");
}
break;
}
case 3:
// JOIN
D(3, "JOIN");
if (sjOnce) {
sjOnce = false;
if (!c.domStack.empty() && c.domStack.top().uni) {
D(2, "Uni branch at join");
printf("NEW DOMESTACK: \n");
c.tmask = c.domStack.top().tmask;
c.domStack.pop();
break;
}
if (!c.domStack.top().fallThrough) {
if (!pcSet) {
nextPc = c.domStack.top().pc;
D(3, "join: NOT FALLTHROUGH PC: " << hex << nextPc << dec);
}
pcSet = true;
}
D(3, "Join: Old TM: ");
for (auto y : c.tmask)
D(3, y << " ");
cout << "\n";
c.tmask = c.domStack.top().tmask;
D(3, "Join: New TM: ");
for (auto y : c.tmask)
D(3, y << " ");
c.domStack.pop();
}
break;
case 4:
trace_inst->stall_warp = true;
// is_barrier
break;
case 0:
// TMC
D(3, "TMC: r" << rsrc[0]);
trace_inst->stall_warp = true;
nextActiveThreads = std::min<unsigned>(reg[rsrc[0]], c.core->a.getNThds());
{
for (int ff = 0; ff < c.tmask.size(); ff++) {
if (ff < nextActiveThreads) {
c.tmask[ff] = true;
} else {
c.tmask[ff] = false;
}
}
}
if (nextActiveThreads == 0) {
c.spawned = false;
}
break;
default:
cout << "ERROR: UNSUPPORTED GPGPU INSTRUCTION " << *this << "\n";
}
break;
case VSET_ARITH:
D(3, "VSET_ARITH");
is_vec = true;
switch (func3) {
case 0: // vector-vector
trace_inst->vs1 = rsrc[0];
trace_inst->vs2 = rsrc[1];
trace_inst->vd = rdest;
switch (func6) {
case 0: {
is_vec = true;
D(3, "Addition " << rsrc[0] << " " << rsrc[1] << " Dest:" << rdest);
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
vector<Reg<char *>> &mask = c.vreg[0];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *mask_ptr = (uint8_t *)mask[i].val;
uint8_t value = (*mask_ptr & 0x1);
if (vmask || (!vmask && value)) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = *first_ptr + *second_ptr;
D(3, "Adding " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *mask_ptr = (uint16_t *)mask[i].val;
uint16_t value = (*mask_ptr & 0x1);
if (vmask || (!vmask && value)) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = *first_ptr + *second_ptr;
D(3, "Adding " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
}
} else if (c.vtype.vsew == 32) {
D(3, "Doing 32 bit vector addition");
for (Word i = 0; i < c.vl; i++) {
int *mask_ptr = (int *)mask[i].val;
int value = (*mask_ptr & 0x1);
if (vmask || (!vmask && value)) {
int *first_ptr = (int *)vr1[i].val;
int *second_ptr = (int *)vr2[i].val;
int result = *first_ptr + *second_ptr;
D(3, "Adding " << *first_ptr << " + " << *second_ptr << " = " << result);
int *result_ptr = (int *)vd[i].val;
*result_ptr = result;
}
}
}
D(3, "Vector Register state after addition:" << flush);
for (int i = 0; i < c.vreg.size(); i++) {
for (int j = 0; j < c.vreg[0].size(); j++) {
if (c.vtype.vsew == 8) {
uint8_t *ptr_val = (uint8_t *)c.vreg[i][j].val;
D(3, "reg[" << i << "][" << j << "] = " << *ptr_val);
} else if (c.vtype.vsew == 16) {
uint16_t *ptr_val = (uint16_t *)c.vreg[i][j].val;
D(3, "reg[" << i << "][" << j << "] = " << *ptr_val);
} else if (c.vtype.vsew == 32) {
uint32_t *ptr_val = (uint32_t *)c.vreg[i][j].val;
D(3, "reg[" << i << "][" << j << "] = " << *ptr_val);
}
}
}
D(3, "After vector register state after addition" << flush);
} break;
case 24: //vmseq
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr == *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr == *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr == *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 25: //vmsne
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr != *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr != *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr != *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 26: //vmsltu
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 27: //vmslt
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (int8_t i = 0; i < c.vl; i++) {
int8_t *first_ptr = (int8_t *)vr1[i].val;
int8_t *second_ptr = (int8_t *)vr2[i].val;
int8_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int8_t *result_ptr = (int8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (int16_t i = 0; i < c.vl; i++) {
int16_t *first_ptr = (int16_t *)vr1[i].val;
int16_t *second_ptr = (int16_t *)vr2[i].val;
int16_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int16_t *result_ptr = (int16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (int32_t i = 0; i < c.vl; i++) {
int32_t *first_ptr = (int32_t *)vr1[i].val;
int32_t *second_ptr = (int32_t *)vr2[i].val;
int32_t result = (*first_ptr < *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int32_t *result_ptr = (int32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 28: //vmsleu
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 29: //vmsle
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (int8_t i = 0; i < c.vl; i++) {
int8_t *first_ptr = (int8_t *)vr1[i].val;
int8_t *second_ptr = (int8_t *)vr2[i].val;
int8_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int8_t *result_ptr = (int8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (int16_t i = 0; i < c.vl; i++) {
int16_t *first_ptr = (int16_t *)vr1[i].val;
int16_t *second_ptr = (int16_t *)vr2[i].val;
int16_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int16_t *result_ptr = (int16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (int32_t i = 0; i < c.vl; i++) {
int32_t *first_ptr = (int32_t *)vr1[i].val;
int32_t *second_ptr = (int32_t *)vr2[i].val;
int32_t result = (*first_ptr <= *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int32_t *result_ptr = (int32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 30: //vmsgtu
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
case 31: //vmsgt
{
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (int8_t i = 0; i < c.vl; i++) {
int8_t *first_ptr = (int8_t *)vr1[i].val;
int8_t *second_ptr = (int8_t *)vr2[i].val;
int8_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int8_t *result_ptr = (int8_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 16) {
for (int16_t i = 0; i < c.vl; i++) {
int16_t *first_ptr = (int16_t *)vr1[i].val;
int16_t *second_ptr = (int16_t *)vr2[i].val;
int16_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int16_t *result_ptr = (int16_t *)vd[i].val;
*result_ptr = result;
}
} else if (c.vtype.vsew == 32) {
for (int32_t i = 0; i < c.vl; i++) {
int32_t *first_ptr = (int32_t *)vr1[i].val;
int32_t *second_ptr = (int32_t *)vr2[i].val;
int32_t result = (*first_ptr > *second_ptr) ? 1 : 0;
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
int32_t *result_ptr = (int32_t *)vd[i].val;
*result_ptr = result;
}
}
} break;
}
break;
case 2: {
trace_inst->vs1 = rsrc[0];
trace_inst->vs2 = rsrc[1];
trace_inst->vd = rdest;
Word VLMAX = (c.vtype.vlmul * c.VLEN) / c.vtype.vsew;
switch (func6) {
case 24: //vmandnot
{
D(3, "vmandnot");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = (first_value & !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = (first_value & !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = (first_value & !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 25: //vmand
{
D(3, "vmand");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = (first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = (first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = (first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 26: //vmor
{
D(3, "vmor");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = (first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = (first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = (first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
D(3, "VLMAX: " << VLMAX);
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 27: //vmxor
{
D(3, "vmxor");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
uint8_t *result_ptr;
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = (first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = (first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = (first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 28: //vmornot
{
D(3, "vmornot");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = (first_value | !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = (first_value | !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = (first_value | !second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 29: //vmnand
{
D(3, "vmnand");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = !(first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
uint8_t *result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = !(first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = !(first_value & second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 30: //vmnor
{
D(3, "vmnor");
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
uint8_t *result_ptr;
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = !(first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = !(first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
uint16_t *result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = !(first_value | second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
uint32_t *result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 31: //vmxnor
{
D(3, "vmxnor");
uint8_t *result_ptr;
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t first_value = (*first_ptr & 0x1);
uint8_t second_value = (*second_ptr & 0x1);
uint8_t result = !(first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t first_value = (*first_ptr & 0x1);
uint16_t second_value = (*second_ptr & 0x1);
uint16_t result = !(first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t first_value = (*first_ptr & 0x1);
uint32_t second_value = (*second_ptr & 0x1);
uint32_t result = !(first_value ^ second_value);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 37: //vmul
{
D(3, "vmul");
uint8_t *result_ptr;
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 45: //vmacc
{
D(3, "vmacc");
uint8_t *result_ptr;
vector<Reg<char *>> &vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr += result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr += result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (*first_ptr * *second_ptr);
D(3, "Comparing " << *first_ptr << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr += result;
}
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
}
} break;
case 6: {
switch (func6) {
case 0: {
D(3, "vmadd.vx");
uint8_t *result_ptr;
//vector<Reg<char *>> & vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
//uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (reg[rsrc[0]] + *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
//uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (reg[rsrc[0]] + *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
//uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (reg[rsrc[0]] + *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
case 37: //vmul.vx
{
D(3, "vmul.vx");
uint8_t *result_ptr;
//vector<Reg<char *>> & vr1 = c.vreg[rsrc[0]];
vector<Reg<char *>> &vr2 = c.vreg[rsrc[1]];
vector<Reg<char *>> &vd = c.vreg[rdest];
if (c.vtype.vsew == 8) {
for (uint8_t i = 0; i < c.vl; i++) {
//uint8_t *first_ptr = (uint8_t *)vr1[i].val;
uint8_t *second_ptr = (uint8_t *)vr2[i].val;
uint8_t result = (reg[rsrc[0]] * *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = result;
}
for (uint8_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint8_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 16) {
uint16_t *result_ptr;
for (uint16_t i = 0; i < c.vl; i++) {
//uint16_t *first_ptr = (uint16_t *)vr1[i].val;
uint16_t *second_ptr = (uint16_t *)vr2[i].val;
uint16_t result = (reg[rsrc[0]] * *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = result;
}
for (uint16_t i = c.vl; i < VLMAX; i++) {
result_ptr = (uint16_t *)vd[i].val;
*result_ptr = 0;
}
} else if (c.vtype.vsew == 32) {
uint32_t *result_ptr;
for (uint32_t i = 0; i < c.vl; i++) {
//uint32_t *first_ptr = (uint32_t *)vr1[i].val;
uint32_t *second_ptr = (uint32_t *)vr2[i].val;
uint32_t result = (reg[rsrc[0]] * *second_ptr);
D(3, "Comparing " << reg[rsrc[0]] << " + " << *second_ptr << " = " << result);
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = result;
}
for (Word i = c.vl; i < VLMAX; i++) {
result_ptr = (uint32_t *)vd[i].val;
*result_ptr = 0;
}
}
} break;
}
} break;
case 7: {
is_vec = true;
c.vtype.vill = 0; //TODO
c.vtype.vediv = vediv;
c.vtype.vsew = vsew;
c.vtype.vlmul = vlmul;
Word VLMAX = (vlmul * c.VLEN) / vsew;
D(3, "lmul:" << vlmul << " sew:" << vsew << " ediv: " << vediv << "rsrc" << reg[rsrc[0]] << "VLMAX" << VLMAX);
if (reg[rsrc[0]] <= VLMAX) {
c.vl = reg[rsrc[0]];
} else if (reg[rsrc[0]] < 2 * VLMAX) {
c.vl = (int)ceil((reg[rsrc[0]] * 1.0) / 2.0);
D(3, "Length:" << c.vl << ceil(reg[rsrc[0]] / 2));
} else if (reg[rsrc[0]] >= (2 * VLMAX)) {
c.vl = VLMAX;
}
reg[rdest] = c.vl;
D(3, "VL:" << reg[rdest]);
Word regNum(0);
c.vreg.clear();
for (int j = 0; j < 32; j++) {
c.vreg.push_back(vector<Reg<char *>>());
for (int i = 0; i < (c.VLEN / vsew); ++i) {
int *elem_ptr = (int *)malloc(vsew / 8);
for (int f = 0; f < (vsew / 32); f++)
elem_ptr[f] = 0;
c.vreg[j].push_back(Reg<char *>(c.id, regNum++, (char *)elem_ptr));
}
}
} break;
default: {
cout << "default???\n"
<< flush;
}
}
break;
case VL: {
is_vec = true;
D(3, "Executing vector load");
VLMAX = (c.vtype.vlmul * c.VLEN) / c.vtype.vsew;
D(3, "lmul: " << c.vtype.vlmul << " VLEN:" << c.VLEN << "sew: " << c.vtype.vsew);
D(3, "src: " << rsrc[0] << " " << reg[rsrc[0]]);
D(3, "dest" << rdest);
D(3, "width" << vlsWidth);
vector<Reg<char *>> &vd = c.vreg[rdest];
switch (vlsWidth) {
case 6: //load word and unit strided (not checking for unit stride)
{
for (Word i = 0; i < c.vl; i++) {
memAddr = ((reg[rsrc[0]]) & 0xFFFFFFFC) + (i * c.vtype.vsew / 8);
data_read = c.core->mem.read(memAddr, c.supervisorMode);
D(3, "Mem addr: " << std::hex << memAddr << " Data read " << data_read);
int *result_ptr = (int *)vd[i].val;
*result_ptr = data_read;
trace_inst->is_lw = true;
trace_inst->mem_addresses[i] = memAddr;
}
/*for(Word i = c.vl; i < VLMAX; i++){
int * result_ptr = (int *) vd[i].val;
*result_ptr = 0;
}*/
D(3, "Vector Register state ----:");
// for(int i=0; i < 32; i++)
// {
// for(int j=0; j< c.vl; j++)
// {
// cout << "starting iter" << endl;
// if (c.vtype.vsew == 8)
// {
// uint8_t * ptr_val = (uint8_t *) c.vreg[i][j].val;
// std::cout << "reg[" << i << "][" << j << "] = " << *ptr_val << std::endl;
// } else if (c.vtype.vsew == 16)
// {
// uint16_t * ptr_val = (uint16_t *) c.vreg[i][j].val;
// std::cout << "reg[" << i << "][" << j << "] = " << *ptr_val << std::endl;
// } else if (c.vtype.vsew == 32)
// {
// uint32_t * ptr_val = (uint32_t *) c.vreg[i][j].val;
// std::cout << "reg[" << i << "][" << j << "] = " << *ptr_val << std::endl;
// }
// cout << "Finished iter" << endl;
// }
// }
// cout << "Finished loop" << endl;
}
// cout << "aaaaaaaaaaaaaaaaaaaaaa" << endl;
break;
default: {
cout << "Serious default??\n"
<< flush;
} break;
}
break;
} break;
case VS:
is_vec = true;
VLMAX = (c.vtype.vlmul * c.VLEN) / c.vtype.vsew;
for (Word i = 0; i < c.vl; i++) {
// cout << "iter" << endl;
++c.stores;
memAddr = reg[rsrc[0]] + (i * c.vtype.vsew / 8);
// std::cout << "STORE MEM ADDRESS *** : " << std::hex << memAddr << "\n";
trace_inst->is_sw = true;
trace_inst->mem_addresses[i] = memAddr;
switch (vlsWidth) {
case 6: //store word and unit strided (not checking for unit stride)
{
uint32_t *ptr_val = (uint32_t *)c.vreg[vs3][i].val;
D(3, "value: " << flush << (*ptr_val) << flush);
c.core->mem.write(memAddr, *ptr_val, c.supervisorMode, 4);
D(3, "store: " << memAddr << " value:" << *ptr_val << flush);
} break;
default:
cout << "ERROR: UNSUPPORTED S INST\n"
<< flush;
std::abort();
}
// cout << "Loop finished" << endl;
// c.memAccesses.push_back(Warp::MemAccess(true, memAddr));
}
// cout << "After for loop" << endl;
break;
default:
D(3, "pc: " << hex << (c.pc - 4));
D(3, "aERROR: Unsupported instruction: " << *this);
std::abort();
}
// break;
// cout << "outside case" << endl << flush;
}
// std::cout << "finished instruction" << endl << flush;
c.activeThreads = nextActiveThreads;
// if (nextActiveThreads != 0)
// {
// for (int i = 7; i >= c.activeThreads; i--)
// {
// c.tmask[i] = c.tmask[i] && false;
// }
// }
// //std::cout << "new thread mask: ";
// for (int i = 0; i < c.tmask.size(); ++i) //std::cout << " " << c.tmask[i];
// //std::cout << "\n";
// This way, if pc was set by a side effect (such as interrupt), it will
// retain its new value.
if (pcSet) {
c.pc = nextPc;
D(3, "Next PC: " << hex << nextPc << dec);
}
if (nextActiveThreads > c.reg.size()) {
cerr << "Error: attempt to spawn " << nextActiveThreads << " threads. "
<< c.reg.size() << " available.\n";
abort();
}
}
Reference in a new issue View git blame Copy permalink