Functions
std::vector< SimValue >	executeInstructionHelper (const char opName, uint8_t width, const uint64_t inputs, int inputsCount)

Variables
constexpr unsigned	OPC_CUSTOM_0 = 0b0001011

constexpr unsigned	OPC_CUSTOM_1 = 0b0101011

std::map< std::string, int >	customOps = {}

std::unique_ptr< OperationPool >	pool = nullptr

Function Documentation

◆ executeInstructionHelper()

std::vector< SimValue > RISCVInstructionExecutor::executeInstructionHelper	(	const char *	opName,
		uint8_t	width,
		const uint64_t *	inputs,
		int	inputsCount
	)

Helper function that executes an OSAL instruction.

Takes in the opName, instruction width, and the inputs, and returns the output vector.

Parameters

opName	operation to be executed
width	instruction width (typically 32 or 64)
inputs	array of input values
inputsCount	number of values in the inputs array

Returns: vector of SimValue objects.

Definition at line 61 of file RISCVInstructionExecutor.cc.

                     {
    if (RISCVInstructionExecutor::pool == nullptr) {
        RISCVInstructionExecutor::pool = std::make_unique<OperationPool>();
    }
 
    Operation& op = RISCVInstructionExecutor::pool->operation(opName);
    if (&op == &NullOperation::instance()) {
        THROW_EXCEPTION(
            IllegalOperationBehavior,
            std::string("ExecuteInstruction error: No behavior "
                        "implementation found for operation '") +
                opName + "'");
    }
    OperationBehavior& behavior = op.behavior();
 
    if (&behavior == &NullOperationBehavior::instance()) {
        throw std::logic_error(
            std::string("ExecuteInstruction error: No behavior "
                        "implementation found for operation '") +
            opName + "'");
    }
 
    OperationContext opContext(opName);
    behavior.createState(opContext);
 
    if (inputsCount < op.numberOfInputs()) {
        behavior.deleteState(opContext);
        THROW_EXCEPTION(
            IllegalParameters,
            std::string("ExecuteInstruction error: Not enough input values"));
    }
 
    const int opInputs = op.numberOfInputs();
    const int opOutputs = op.numberOfOutputs();
    const int opValues = opInputs + opOutputs;
 
    std::vector<std::unique_ptr<SimValue>> simValues(opValues);
 
    for (int i = 0; i < opInputs; ++i) {
        simValues[i] = std::make_unique<SimValue>(inputs[i], width);
    }
    for (int i = 0; i < opOutputs; ++i) {
        simValues[opInputs + i] = std::make_unique<SimValue>(0, width);
    }
 
    std::vector<SimValue*> simValPtrs(opValues);
    for (int i = 0; i < opValues; ++i) {
        simValPtrs[i] = simValues[i].get();
    }
 
    if (!behavior.simulateTrigger(simValPtrs.data(), opContext)) {
        behavior.deleteState(opContext);
        THROW_EXCEPTION(
            ModuleRunTimeError,
            std::string(
                "ExecuteInstruction error: operation execution failed"));
    }
 
    std::vector<SimValue> results(opOutputs);
    for (int i = 0; i < opOutputs; i++) {
        results[i] = *simValues[opInputs + i];
    }
 
    behavior.deleteState(opContext);
    return results;
}