DBT-RISE-TGC/riscv.sc/src/sysc/core_complex.cpp

////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2017, MINRES Technologies GmbH
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. 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.
//
// 3. Neither the name of the copyright holder 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 HOLDER 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.
//
// Contributors:
//       eyck@minres.com - initial API and implementation
//
//
////////////////////////////////////////////////////////////////////////////////

#include "scc/report.h"
#include "iss/arch/riscv_hart_msu_vp.h"
#include "iss/arch/rv32imac.h"
#include "iss/iss.h"
#include "iss/vm_types.h"
#include "iss/debugger/server.h"
#include "iss/debugger/gdb_session.h"
#include "iss/debugger/target_adapter_if.h"
#include "iss/debugger/encoderdecoder.h"
#include "sysc/SiFive/core_complex.h"

#ifdef WITH_SCV
#include <scv.h>
#endif

namespace sysc {
namespace SiFive {
namespace {
iss::debugger::encoder_decoder encdec;

}
namespace {

const char lvl[] = {'U', 'S', 'H', 'M'};

const char *trap_str[] = {"Instruction address misaligned",
                          "Instruction access fault",
                          "Illegal instruction",
                          "Breakpoint",
                          "Load address misaligned",
                          "Load access fault",
                          "Store/AMO address misaligned",
                          "Store/AMO access fault",
                          "Environment call from U-mode",
                          "Environment call from S-mode",
                          "Reserved",
                          "Environment call from M-mode",
                          "Instruction page fault",
                          "Load page fault",
                          "Reserved",
                          "Store/AMO page fault"};
const char *irq_str[] = {
    "User software interrupt", "Supervisor software interrupt", "Reserved", "Machine software interrupt",
    "User timer interrupt",    "Supervisor timer interrupt",    "Reserved", "Machine timer interrupt",
    "User external interrupt", "Supervisor external interrupt", "Reserved", "Machine external interrupt"};
}

class core_wrapper : public iss::arch::riscv_hart_msu_vp<iss::arch::rv32imac> {
public:
    using core_type = iss::arch::rv32imac;
    using base_type = iss::arch::riscv_hart_msu_vp<iss::arch::rv32imac>;
    using phys_addr_t = typename iss::arch::traits<iss::arch::rv32imac>::phys_addr_t;
    core_wrapper(core_complex *owner)
    : owner(owner)
    {}

    uint32_t get_mode(){ return this->reg.machine_state; }

    base_type::hart_state<base_type::reg_t>& get_state() { return this->state; }

    void notify_phase(iss::arch_if::exec_phase phase);

    void disass_output(uint64_t pc, const std::string instr) override {
#ifndef WITH_SCV
        std::stringstream s;
        s << "[p:" << lvl[this->reg.machine_state] << ";s:0x" << std::hex << std::setfill('0')
          << std::setw(sizeof(reg_t) * 2) << (reg_t)state.mstatus << std::dec << ";c:" << this->reg.icount << "]";
        CLOG(INFO, disass) << "0x"<<std::setw(16)<<std::setfill('0')<<std::hex<<pc<<"\t\t"<<instr<<"\t"<<s.str();
#else
        owner->disass_output(pc,instr);
#endif
    };

    iss::status read_mem(phys_addr_t addr, unsigned length, uint8_t *const data) {
        if (addr.type & iss::DEBUG)
            return owner->read_mem_dbg(addr.val, length, data) ? iss::Ok : iss::Err;
        else {
            return owner->read_mem(addr.val, length, data,addr.type && iss::FETCH) ? iss::Ok : iss::Err;
        }
    }

    iss::status write_mem(phys_addr_t addr, unsigned length, const uint8_t *const data) {
        if (addr.type & iss::DEBUG)
            return owner->write_mem_dbg(addr.val, length, data) ? iss::Ok : iss::Err;
        else
            return owner->write_mem(addr.val, length, data) ? iss::Ok : iss::Err;
    }

private:
    core_complex *const owner;
};

int cmd_sysc(int argc, char* argv[], iss::debugger::out_func of, iss::debugger::data_func df, iss::debugger::target_adapter_if* tgt_adapter){
    if(argc>1) {
        if(strcasecmp(argv[1], "print_time")==0){
            std::string t = sc_core::sc_time_stamp().to_string();
            of(t.c_str());
            char buf[64];
            encdec.enc_string(t.c_str(), buf, 63);
            df(buf);
            return iss::Ok;
        } else if(strcasecmp(argv[1], "break")==0){
            sc_core::sc_time t;
            if(argc==4){
                 t= scc::parse_from_string(argv[2], argv[3]);
            } else if(argc==3){
                t= scc::parse_from_string(argv[2]);
            } else
                return iss::Err;
            // no check needed as it is only called if debug server is active
            tgt_adapter->add_break_condition([t]()->unsigned{
                LOG(TRACE)<<"Checking condition at "<<sc_core::sc_time_stamp();
                return sc_core::sc_time_stamp()>=t?std::numeric_limits<unsigned>::max():0;
            });
            return iss::Ok;
        }
        return iss::Err;
    }
    return iss::Err;

}

void core_wrapper::notify_phase(exec_phase phase) {
    core_type::notify_phase(phase);
    if (phase == ISTART) owner->sync();
}

core_complex::core_complex(sc_core::sc_module_name name)
: sc_core::sc_module(name)
, NAMED(initiator)
, NAMED(clk_i)
, NAMED(rst_i)
, NAMED(elf_file, this)
, NAMED(enable_disass, true, this)
, NAMED(reset_address, 0ULL, this)
, NAMED(gdb_server_port, 0, this)
, NAMED(dump_ir, false, this)
, read_lut(tlm_dmi_ext())
, write_lut(tlm_dmi_ext())
, tgt_adapter(nullptr)
#ifdef WITH_SCV
, m_db(scv_tr_db::get_default_db())
, stream_handle(nullptr)
, instr_tr_handle(nullptr)
, fetch_tr_handle(nullptr)
#endif
{

    initiator.register_invalidate_direct_mem_ptr([=](uint64_t start, uint64_t end) -> void {
        auto lut_entry = read_lut.getEntry(start);
        if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && end <= lut_entry.get_end_address() + 1) {
            read_lut.removeEntry(lut_entry);
        }
        lut_entry = write_lut.getEntry(start);
        if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && end <= lut_entry.get_end_address() + 1) {
            write_lut.removeEntry(lut_entry);
        }
    });

    SC_THREAD(run);
    SC_METHOD(clk_cb);
    sensitive << clk_i;
}

core_complex::~core_complex() = default;

void core_complex::trace(sc_core::sc_trace_file *trf) {}

void core_complex::before_end_of_elaboration() {
    cpu = std::make_unique<core_wrapper>(this);
    vm = iss::create<iss::arch::rv32imac>(cpu.get(), gdb_server_port.value, dump_ir.value);
    vm->setDisassEnabled(enable_disass.value);
    auto* srv = iss::debugger::server<iss::debugger::gdb_session>::get();
    if(srv) tgt_adapter = srv->get_target();
    if(tgt_adapter)
        tgt_adapter->add_custom_command({
        "sysc",
        [this](int argc, char* argv[], iss::debugger::out_func of, iss::debugger::data_func df)-> int {
            return cmd_sysc(argc, argv, of, df, tgt_adapter);
        },
        "SystemC sub-commands: break <time>, print_time"});
}

void core_complex::start_of_simulation() {
    quantum_keeper.reset();
    if (elf_file.value.size() > 0) cpu->load_file(elf_file.value);
#ifdef WITH_SCV
        if (stream_handle == NULL) {
            string basename(this->name());
            stream_handle = new scv_tr_stream((basename + ".instr").c_str(), "TRANSACTOR", m_db);
            instr_tr_handle = new scv_tr_generator<>("execute", *stream_handle);
            fetch_tr_handle = new scv_tr_generator<uint64_t>("fetch", *stream_handle);
        }
#endif
}

void core_complex::disass_output(uint64_t pc, const std::string instr_str) {
#ifdef WITH_SCV
    if(tr_handle.is_active()) tr_handle.end_transaction();
    tr_handle = instr_tr_handle->begin_transaction();
    tr_handle.record_attribute("PC", pc);
    tr_handle.record_attribute("INSTR", instr_str);
    tr_handle.record_attribute("MODE", lvl[cpu->get_mode()]);
    tr_handle.record_attribute("MSTATUS", cpu->get_state().mstatus.st.value);
#endif
}

void core_complex::clk_cb() { curr_clk = clk_i.read(); }

void core_complex::run() {
    wait(sc_core::SC_ZERO_TIME);
    cpu->reset(reset_address.value);
    try {
        vm->start(-1);
    } catch (iss::simulation_stopped &e) {
    }
    sc_core::sc_stop();
}

bool core_complex::read_mem(uint64_t addr, unsigned length, uint8_t *const data, bool is_fetch) {
    auto lut_entry = read_lut.getEntry(addr);
    if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
        addr + length <= lut_entry.get_end_address() + 1) {
        auto offset = addr - lut_entry.get_start_address();
        std::copy(lut_entry.get_dmi_ptr() + offset, lut_entry.get_dmi_ptr() + offset + length, data);
        quantum_keeper.inc(lut_entry.get_read_latency());
        return true;
    } else {
        tlm::tlm_generic_payload gp;
        gp.set_command(tlm::TLM_READ_COMMAND);
        gp.set_address(addr);
        gp.set_data_ptr(data);
        gp.set_data_length(length);
        gp.set_streaming_width(4);
        auto delay{quantum_keeper.get_local_time()};
#ifdef WITH_SCV
        if(tr_handle.is_valid()){
            if(is_fetch && tr_handle.is_active()) tr_handle.end_transaction();
            auto preExt = new scv4tlm::tlm_recording_extension(tr_handle, this);
            gp.set_extension(preExt);
        }
#endif
        initiator->b_transport(gp, delay);
        LOG(TRACE) << "read_mem(0x" << std::hex << addr << ") : " << data;
        if (gp.get_response_status() != tlm::TLM_OK_RESPONSE) {
            return false;
        }
        if (gp.is_dmi_allowed()) {
            gp.set_command(tlm::TLM_READ_COMMAND);
            gp.set_address(addr);
            tlm_dmi_ext dmi_data;
            if (initiator->get_direct_mem_ptr(gp, dmi_data)) {
                if (dmi_data.is_read_allowed())
                    read_lut.addEntry(dmi_data, dmi_data.get_start_address(),
                                      dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
                if (dmi_data.is_write_allowed())
                    write_lut.addEntry(dmi_data, dmi_data.get_start_address(),
                                       dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
            }
        }
        return true;
    }
}

bool core_complex::write_mem(uint64_t addr, unsigned length, const uint8_t *const data) {
    auto lut_entry = write_lut.getEntry(addr);
    if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
        addr + length <= lut_entry.get_end_address() + 1) {
        auto offset = addr - lut_entry.get_start_address();
        std::copy(data, data + length, lut_entry.get_dmi_ptr() + offset);
        quantum_keeper.inc(lut_entry.get_read_latency());
        return true;
    } else {
        write_buf.resize(length);
        std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
        tlm::tlm_generic_payload gp;
        gp.set_command(tlm::TLM_WRITE_COMMAND);
        gp.set_address(addr);
        gp.set_data_ptr(write_buf.data());
        gp.set_data_length(length);
        gp.set_streaming_width(4);
        auto delay{quantum_keeper.get_local_time()};
        initiator->b_transport(gp, delay);
        quantum_keeper.set(delay);
        LOG(TRACE) << "write_mem(0x" << std::hex << addr << ") : " << data;
        if (gp.get_response_status() != tlm::TLM_OK_RESPONSE) {
            return false;
        }
        if (gp.is_dmi_allowed()) {
            gp.set_command(tlm::TLM_READ_COMMAND);
            gp.set_address(addr);
            tlm_dmi_ext dmi_data;
            if (initiator->get_direct_mem_ptr(gp, dmi_data)) {
                if (dmi_data.is_read_allowed())
                    read_lut.addEntry(dmi_data, dmi_data.get_start_address(),
                                      dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
                if (dmi_data.is_write_allowed())
                    write_lut.addEntry(dmi_data, dmi_data.get_start_address(),
                                       dmi_data.get_end_address() - dmi_data.get_start_address() + 1);
            }
        }
        return true;
    }
}

bool core_complex::read_mem_dbg(uint64_t addr, unsigned length, uint8_t *const data) {
    auto lut_entry = read_lut.getEntry(addr);
    if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
        addr + length <= lut_entry.get_end_address() + 1) {
        auto offset = addr - lut_entry.get_start_address();
        std::copy(lut_entry.get_dmi_ptr() + offset, lut_entry.get_dmi_ptr() + offset + length, data);
        quantum_keeper.inc(lut_entry.get_read_latency());
        return true;
    } else {
        tlm::tlm_generic_payload gp;
        gp.set_command(tlm::TLM_READ_COMMAND);
        gp.set_address(addr);
        gp.set_data_ptr(data);
        gp.set_data_length(length);
        gp.set_streaming_width(length);
        return initiator->transport_dbg(gp) == length;
    }
}

bool core_complex::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t *const data) {
    auto lut_entry = write_lut.getEntry(addr);
    if (lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE &&
        addr + length <= lut_entry.get_end_address() + 1) {
        auto offset = addr - lut_entry.get_start_address();
        std::copy(data, data + length, lut_entry.get_dmi_ptr() + offset);
        quantum_keeper.inc(lut_entry.get_read_latency());
        return true;
    } else {
        write_buf.resize(length);
        std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
        tlm::tlm_generic_payload gp;
        gp.set_command(tlm::TLM_WRITE_COMMAND);
        gp.set_address(addr);
        gp.set_data_ptr(write_buf.data());
        gp.set_data_length(length);
        gp.set_streaming_width(length);
        return initiator->transport_dbg(gp) == length;
    }
}

} /* namespace SiFive */
} /* namespace sysc */