+// See LICENSE for license details.
+
#include "processor.h"
-#include <bfd.h>
-#include <dis-asm.h>
-#include <cmath>
-#include <cstdlib>
-#include <iostream>
+#include "extension.h"
#include "common.h"
#include "config.h"
#include "sim.h"
-#include "icsim.h"
-#include "softfloat.h"
-#include "platform.h" // softfloat isNaNF32UI, etc.
-#include "internals.h" // ditto
-
-processor_t::processor_t(sim_t* _sim, char* _mem, size_t _memsz)
- : sim(_sim), mmu(_mem,_memsz)
+#include "htif.h"
+#include "disasm.h"
+#include "icache.h"
+#include <cinttypes>
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+#include <assert.h>
+#include <limits.h>
+#include <stdexcept>
+#include <algorithm>
+
+processor_t::processor_t(sim_t* _sim, mmu_t* _mmu, uint32_t _id)
+ : sim(_sim), mmu(_mmu), ext(NULL), disassembler(new disassembler_t),
+ id(_id), run(false), debug(false)
{
- // a few assumptions about endianness, including freg_t union
- static_assert(BYTE_ORDER == LITTLE_ENDIAN);
- static_assert(sizeof(freg_t) == 8);
- static_assert(sizeof(reg_t) == 8);
-
- static_assert(sizeof(insn_t) == 4);
- static_assert(sizeof(uint128_t) == 16 && sizeof(int128_t) == 16);
+ reset(true);
+ mmu->set_processor(this);
- icsim = NULL;
- dcsim = NULL;
- itlbsim = NULL;
- dtlbsim = NULL;
-
- reset();
+ #define DECLARE_INSN(name, match, mask) REGISTER_INSN(this, name, match, mask)
+ #include "encoding.h"
+ #undef DECLARE_INSN
+ build_opcode_map();
}
processor_t::~processor_t()
{
- if(icsim)
- icsim->print_stats();
- delete icsim;
-
- if(itlbsim)
- itlbsim->print_stats();
- delete itlbsim;
-
- if(dcsim)
- dcsim->print_stats();
- delete dcsim;
-
- if(dtlbsim)
- dtlbsim->print_stats();
- delete dtlbsim;
+ delete disassembler;
}
-void processor_t::init(uint32_t _id, icsim_t* default_icache,
- icsim_t* default_dcache)
+void state_t::reset()
{
- id = _id;
-
- for (int i=0; i<MAX_UTS; i++)
- {
- uts[i] = new processor_t(sim, mmu.mem, mmu.memsz);
- uts[i]->id = id;
- uts[i]->set_sr(uts[i]->sr | SR_EF);
- uts[i]->set_sr(uts[i]->sr | SR_EV);
- uts[i]->utidx = i;
- }
+ // the ISA guarantees on boot that the PC is 0x2000 and the the processor
+ // is in supervisor mode, and in 64-bit mode, if supported, with traps
+ // and virtual memory disabled.
+ sr = SR_S | SR_S64;
+ pc = 0x2000;
- #ifdef RISCV_ENABLE_ICSIM
- icsim = new icsim_t(*default_icache);
- mmu.set_icsim(icsim);
- itlbsim = new icsim_t(1, 8, 4096, "ITLB");
- mmu.set_itlbsim(itlbsim);
- #endif
- #ifdef RISCV_ENABLE_ICSIM
- dcsim = new icsim_t(*default_dcache);
- mmu.set_dcsim(dcsim);
- dtlbsim = new icsim_t(1, 8, 4096, "DTLB");
- mmu.set_dtlbsim(dtlbsim);
- #endif
-}
+ // the following state is undefined upon boot-up,
+ // but we zero it for determinism
+ XPR.reset();
+ FPR.reset();
-void processor_t::reset()
-{
- run = false;
-
- memset(XPR,0,sizeof(XPR));
- memset(FPR,0,sizeof(FPR));
-
- pc = 0;
- evec = 0;
epc = 0;
badvaddr = 0;
- cause = 0;
+ evec = 0;
+ ptbr = 0;
pcr_k0 = 0;
pcr_k1 = 0;
+ cause = 0;
tohost = 0;
fromhost = 0;
count = 0;
compare = 0;
- cycle = 0;
- set_sr(SR_S | SR_SX); // SX ignored if 64b mode not supported
- set_fsr(0);
-
- // vector stuff
- vecbanks = 0xff;
- vecbanks_count = 8;
- utidx = -1;
- vlmax = 32;
- vl = 0;
- nxfpr_bank = 256;
- nxpr_use = 32;
- nfpr_use = 32;
- for (int i=0; i<MAX_UTS; i++)
- uts[i] = NULL;
-}
-
-void processor_t::set_sr(uint32_t val)
-{
- sr = val & ~SR_ZERO;
-#ifndef RISCV_ENABLE_64BIT
- sr &= ~(SR_SX | SR_UX);
-#endif
-#ifndef RISCV_ENABLE_FPU
- sr &= ~SR_EF;
-#endif
-#ifndef RISCV_ENABLE_RVC
- sr &= ~SR_EC;
-#endif
-#ifndef RISCV_ENABLE_VEC
- sr &= ~SR_EV;
-#endif
+ fflags = 0;
+ frm = 0;
- mmu.set_vm_enabled(sr & SR_VM);
- mmu.set_supervisor(sr & SR_S);
- mmu.flush_tlb();
+ load_reservation = -1;
+}
- xprlen = ((sr & SR_S) ? (sr & SR_SX) : (sr & SR_UX)) ? 64 : 32;
+void processor_t::set_debug(bool value)
+{
+ debug = value;
+ if (ext)
+ ext->set_debug(value);
}
-void processor_t::set_fsr(uint32_t val)
+void processor_t::reset(bool value)
{
- fsr = val & ~FSR_ZERO;
+ if (run == !value)
+ return;
+ run = !value;
+
+ state.reset(); // reset the core
+ set_pcr(CSR_STATUS, state.sr);
+
+ if (ext)
+ ext->reset(); // reset the extension
}
-void processor_t::vcfg()
+void processor_t::take_interrupt()
{
- if (nxpr_use + nfpr_use < 2)
- vlmax = nxfpr_bank * vecbanks_count;
- else
- vlmax = (nxfpr_bank / (nxpr_use + nfpr_use - 1)) * vecbanks_count;
+ uint32_t interrupts = (state.sr & SR_IP) >> SR_IP_SHIFT;
+ interrupts &= (state.sr & SR_IM) >> SR_IM_SHIFT;
- vlmax = std::min(vlmax, MAX_UTS);
+ if (interrupts && (state.sr & SR_EI))
+ for (int i = 0; ; i++, interrupts >>= 1)
+ if (interrupts & 1)
+ throw trap_t((1ULL << ((state.sr & SR_S64) ? 63 : 31)) + i);
}
-void processor_t::setvl(int vlapp)
+static void commit_log(state_t* state, insn_t insn)
{
- vl = std::min(vlmax, vlapp);
+#ifdef RISCV_ENABLE_COMMITLOG
+ if (!(state->sr & SR_S))
+ fprintf(stderr, "\n0x%016" PRIx64 " (0x%08" PRIx32 ") ", state->pc, insn.bits());
+#endif
}
-void processor_t::step(size_t n, bool noisy)
+void processor_t::step(size_t n)
{
- size_t i = 0;
- while(run) try
+ if(!run)
+ return;
+
+ mmu_t* _mmu = mmu;
+ auto count32 = decltype(state.compare)(state.count);
+ bool count_le_compare = count32 <= state.compare;
+ n = std::min(n, size_t(state.compare - count32) | 1);
+
+ try
{
- for( ; i < n; i++)
+ take_interrupt();
+
+ if (debug) // print out instructions as we go
{
- uint32_t interrupts = (cause & CAUSE_IP) >> CAUSE_IP_SHIFT;
- interrupts &= (sr & SR_IM) >> SR_IM_SHIFT;
- if(interrupts && (sr & SR_ET))
- take_trap(trap_interrupt,noisy);
-
- insn_t insn = mmu.load_insn(pc, sr & SR_EC);
-
- reg_t npc = pc + insn_length(insn);
-
- if(noisy)
- disasm(insn,pc);
-
- #include "execute.h"
-
- pc = npc;
- XPR[0] = 0;
-
- if(count++ == compare)
- cause |= 1 << (TIMER_IRQ+CAUSE_IP_SHIFT);
- cycle++;
+ for (size_t i = 0; i < n; state.count++, i++)
+ {
+ insn_fetch_t fetch = mmu->load_insn(state.pc);
+ disasm(fetch.insn.insn);
+ commit_log(&state, fetch.insn.insn);
+ state.pc = fetch.func(this, fetch.insn.insn, state.pc);
+ }
+ }
+ else while (n > 0)
+ {
+ size_t idx = (state.pc / sizeof(insn_t)) % ICACHE_SIZE;
+ auto ic_entry = _mmu->access_icache(state.pc), ic_entry_init = ic_entry;
+
+ #define ICACHE_ACCESS(idx) { \
+ insn_t insn = ic_entry->data.insn.insn; \
+ insn_func_t func = ic_entry->data.func; \
+ commit_log(&state, insn); \
+ ic_entry++; \
+ state.pc = func(this, insn, state.pc); \
+ if (idx < ICACHE_SIZE-1 && unlikely(ic_entry->tag != state.pc)) break; \
+ }
+
+ switch (idx)
+ {
+ ICACHE_SWITCH; // auto-generated into icache.h
+ }
+
+ size_t i = ic_entry - ic_entry_init;
+ state.count += i;
+ if (i >= n)
+ break;
+ n -= i;
}
- return;
}
- catch(trap_t t)
+ catch(trap_t& t)
{
- i++;
- take_trap(t,noisy);
+ take_trap(t);
}
- catch(vt_command_t cmd)
+
+ bool count_ge_compare =
+ uint64_t(n) + decltype(state.compare)(state.count) >= state.compare;
+ if (count_le_compare && count_ge_compare)
+ set_interrupt(IRQ_TIMER, true);
+}
+
+void processor_t::take_trap(trap_t& t)
+{
+ if (debug)
+ fprintf(stderr, "core %3d: exception %s, epc 0x%016" PRIx64 "\n",
+ id, t.name(), state.pc);
+
+ // switch to supervisor, set previous supervisor bit, disable interrupts
+ set_pcr(CSR_STATUS, (((state.sr & ~SR_EI) | SR_S) & ~SR_PS & ~SR_PEI) |
+ ((state.sr & SR_S) ? SR_PS : 0) |
+ ((state.sr & SR_EI) ? SR_PEI : 0));
+
+ yield_load_reservation();
+ state.cause = t.cause();
+ state.epc = state.pc;
+ state.pc = state.evec;
+
+ t.side_effects(&state); // might set badvaddr etc.
+}
+
+void processor_t::deliver_ipi()
+{
+ if (run)
+ set_pcr(CSR_CLEAR_IPI, 1);
+}
+
+void processor_t::disasm(insn_t insn)
+{
+ // the disassembler is stateless, so we share it
+ fprintf(stderr, "core %3d: 0x%016" PRIx64 " (0x%08" PRIx32 ") %s\n",
+ id, state.pc, insn.bits(), disassembler->disassemble(insn).c_str());
+}
+
+reg_t processor_t::set_pcr(int which, reg_t val)
+{
+ reg_t old_pcr = get_pcr(which);
+
+ switch (which)
{
- if (cmd == vt_command_stop)
- return;
+ case CSR_FFLAGS:
+ state.fflags = val & (FSR_AEXC >> FSR_AEXC_SHIFT);
+ break;
+ case CSR_FRM:
+ state.frm = val & (FSR_RD >> FSR_RD_SHIFT);
+ break;
+ case CSR_FCSR:
+ state.fflags = (val & FSR_AEXC) >> FSR_AEXC_SHIFT;
+ state.frm = (val & FSR_RD) >> FSR_RD_SHIFT;
+ break;
+ case CSR_STATUS:
+ state.sr = (val & ~SR_IP) | (state.sr & SR_IP);
+#ifndef RISCV_ENABLE_64BIT
+ state.sr &= ~(SR_S64 | SR_U64);
+#endif
+#ifndef RISCV_ENABLE_FPU
+ state.sr &= ~SR_EF;
+#endif
+ if (!ext)
+ state.sr &= ~SR_EA;
+ state.sr &= ~SR_ZERO;
+ rv64 = (state.sr & SR_S) ? (state.sr & SR_S64) : (state.sr & SR_U64);
+ mmu->flush_tlb();
+ break;
+ case CSR_EPC:
+ state.epc = val;
+ break;
+ case CSR_EVEC:
+ state.evec = val & ~3;
+ break;
+ case CSR_CYCLE:
+ case CSR_TIME:
+ case CSR_INSTRET:
+ case CSR_COUNT:
+ state.count = val;
+ break;
+ case CSR_COMPARE:
+ set_interrupt(IRQ_TIMER, false);
+ state.compare = val;
+ break;
+ case CSR_PTBR:
+ state.ptbr = val & ~(PGSIZE-1);
+ break;
+ case CSR_SEND_IPI:
+ sim->send_ipi(val);
+ break;
+ case CSR_CLEAR_IPI:
+ set_interrupt(IRQ_IPI, val & 1);
+ break;
+ case CSR_SUP0:
+ state.pcr_k0 = val;
+ break;
+ case CSR_SUP1:
+ state.pcr_k1 = val;
+ break;
+ case CSR_TOHOST:
+ if (state.tohost == 0)
+ state.tohost = val;
+ break;
+ case CSR_FROMHOST:
+ set_fromhost(val);
+ break;
}
- catch(halt_t t)
+
+ return old_pcr;
+}
+
+void processor_t::set_fromhost(reg_t val)
+{
+ set_interrupt(IRQ_HOST, val != 0);
+ state.fromhost = val;
+}
+
+reg_t processor_t::get_pcr(int which)
+{
+ switch (which)
{
- reset();
+ case CSR_FFLAGS:
+ return state.fflags;
+ case CSR_FRM:
+ return state.frm;
+ case CSR_FCSR:
+ return (state.fflags << FSR_AEXC_SHIFT) | (state.frm << FSR_RD_SHIFT);
+ case CSR_STATUS:
+ return state.sr;
+ case CSR_EPC:
+ return state.epc;
+ case CSR_BADVADDR:
+ return state.badvaddr;
+ case CSR_EVEC:
+ return state.evec;
+ case CSR_CYCLE:
+ case CSR_TIME:
+ case CSR_INSTRET:
+ case CSR_COUNT:
+ return state.count;
+ case CSR_COMPARE:
+ return state.compare;
+ case CSR_CAUSE:
+ return state.cause;
+ case CSR_PTBR:
+ return state.ptbr;
+ case CSR_SEND_IPI:
+ case CSR_CLEAR_IPI:
+ return 0;
+ case CSR_ASID:
+ return 0;
+ case CSR_FATC:
+ mmu->flush_tlb();
+ return 0;
+ case CSR_HARTID:
+ return id;
+ case CSR_IMPL:
+ return 1;
+ case CSR_SUP0:
+ return state.pcr_k0;
+ case CSR_SUP1:
+ return state.pcr_k1;
+ case CSR_TOHOST:
+ sim->get_htif()->tick(); // not necessary, but faster
+ return state.tohost;
+ case CSR_FROMHOST:
+ sim->get_htif()->tick(); // not necessary, but faster
+ return state.fromhost;
+ default:
+ throw trap_illegal_instruction();
}
}
-void processor_t::take_trap(trap_t t, bool noisy)
+void processor_t::set_interrupt(int which, bool on)
{
- demand(t < NUM_TRAPS, "internal error: bad trap number %d", int(t));
- demand(sr & SR_ET, "error mode on core %d!\ntrap %s, pc 0x%016llx",
- id, trap_name(t), (unsigned long long)pc);
- if(noisy)
- printf("core %3d: trap %s, pc 0x%016llx\n",
- id, trap_name(t), (unsigned long long)pc);
+ uint32_t mask = (1 << (which + SR_IP_SHIFT)) & SR_IP;
+ if (on)
+ state.sr |= mask;
+ else
+ state.sr &= ~mask;
+}
- set_sr((((sr & ~SR_ET) | SR_S) & ~SR_PS) | ((sr & SR_S) ? SR_PS : 0));
- cause = (cause & ~CAUSE_EXCCODE) | (t << CAUSE_EXCCODE_SHIFT);
- epc = pc;
- pc = evec;
- badvaddr = mmu.get_badvaddr();
+reg_t illegal_instruction(processor_t* p, insn_t insn, reg_t pc)
+{
+ throw trap_illegal_instruction();
}
-void processor_t::deliver_ipi()
+insn_func_t processor_t::decode_insn(insn_t insn)
+{
+ size_t mask = opcode_map.size()-1;
+ insn_desc_t* desc = opcode_map[insn.bits() & mask];
+
+ while ((insn.bits() & desc->mask) != desc->match)
+ desc++;
+
+ return rv64 ? desc->rv64 : desc->rv32;
+}
+
+void processor_t::register_insn(insn_desc_t desc)
{
- cause |= 1 << (IPI_IRQ+CAUSE_IP_SHIFT);
- run = true;
+ assert(desc.mask & 1);
+ instructions.push_back(desc);
}
-void processor_t::disasm(insn_t insn, reg_t pc)
+void processor_t::build_opcode_map()
{
- printf("core %3d: 0x%016llx (0x%08x) ",id,(unsigned long long)pc,insn.bits);
+ size_t buckets = -1;
+ for (auto& inst : instructions)
+ while ((inst.mask & buckets) != buckets)
+ buckets /= 2;
+ buckets++;
+
+ struct cmp {
+ decltype(insn_desc_t::match) mask;
+ cmp(decltype(mask) mask) : mask(mask) {}
+ bool operator()(const insn_desc_t& lhs, const insn_desc_t& rhs) {
+ if ((lhs.match & mask) != (rhs.match & mask))
+ return (lhs.match & mask) < (rhs.match & mask);
+ return lhs.match < rhs.match;
+ }
+ };
+ std::sort(instructions.begin(), instructions.end(), cmp(buckets-1));
- #ifdef RISCV_HAVE_LIBOPCODES
- disassemble_info info;
- INIT_DISASSEMBLE_INFO(info, stdout, fprintf);
- info.flavour = bfd_target_unknown_flavour;
- info.arch = bfd_arch_mips;
- info.mach = 101; // XXX bfd_mach_mips_riscv requires modified bfd.h
- info.endian = BFD_ENDIAN_LITTLE;
- info.buffer = (bfd_byte*)&insn;
- info.buffer_length = sizeof(insn);
- info.buffer_vma = pc;
+ opcode_map.resize(buckets);
+ opcode_store.resize(instructions.size() + 1);
- int ret = print_insn_little_mips(pc, &info);
- demand(ret == (INSN_IS_RVC(insn.bits) ? 2 : 4), "disasm bug!");
- #else
- printf("unknown");
- #endif
- printf("\n");
+ size_t j = 0;
+ for (size_t b = 0, i = 0; b < buckets; b++)
+ {
+ opcode_map[b] = &opcode_store[j];
+ while (i < instructions.size() && b == (instructions[i].match & (buckets-1)))
+ opcode_store[j++] = instructions[i++];
+ }
+
+ assert(j == opcode_store.size()-1);
+ opcode_store[j].match = opcode_store[j].mask = 0;
+ opcode_store[j].rv32 = &illegal_instruction;
+ opcode_store[j].rv64 = &illegal_instruction;
+}
+
+void processor_t::register_extension(extension_t* x)
+{
+ for (auto insn : x->get_instructions())
+ register_insn(insn);
+ build_opcode_map();
+ for (auto disasm_insn : x->get_disasms())
+ disassembler->add_insn(disasm_insn);
+ if (ext != NULL)
+ throw std::logic_error("only one extension may be registered");
+ ext = x;
+ x->set_processor(this);
}