RISCVInstructionExecutor.cc File Reference

#include <memory>
#include <string>
#include <vector>
#include "BEMGenerator.hh"
#include "BinaryEncoding.hh"
#include "InstructionFormat.hh"
#include "Machine.hh"
#include "Operation.hh"
#include "OperationContext.hh"
#include "OperationPool.hh"
#include "RISCVFields.hh"
#include "RISCVTools.hh"

Include dependency graph for RISCVInstructionExecutor.cc:

Go to the source code of this file.

Namespaces
namespace	RISCVInstructionExecutor

Functions
std::vector< SimValue >	RISCVInstructionExecutor::executeInstructionHelper (const char *opName, uint8_t width, const uint64_t *inputs, int inputsCount)
int	initializeMachine (const char *machinePath, char **error)
int	resetMachine ()
int	unpackInstruction (uint32_t instruction, char **output, char **error)
int	executeInstruction32 (const char *opName, const uint32_t *inputs, uint32_t inputsCount, uint32_t *output, char **error)
int	executeInstruction64 (const char *opName, const uint64_t *inputs, uint32_t inputsCount, uint64_t *output, char **error)

Variables
constexpr unsigned	RISCVInstructionExecutor::OPC_CUSTOM_0 = 0b0001011
constexpr unsigned	RISCVInstructionExecutor::OPC_CUSTOM_1 = 0b0101011
std::map< std::string, int >	RISCVInstructionExecutor::customOps = {}
std::unique_ptr< OperationPool >	RISCVInstructionExecutor::pool = nullptr

Detailed Description

Definition of RISCVInstructionExecutor class.

Author

Eetu Soronen 2025 (eetu..nosp@m.soro.nosp@m.nen@t.nosp@m.uni..nosp@m.fi)

Note

rating: red

Definition in file RISCVInstructionExecutor.cc.

Function Documentation

executeInstruction32()

int executeInstruction32	(	const char *	opName,
		const uint32_t *	inputs,
		uint32_t	inputsCount,
		uint32_t *	output,
		char **	error
	)

Executes a custom 32-wide instruction.

The instruction behavior is searched automatically by OperationPool from the OSAL search paths. See chapter 4.4 in the manual.

Parameters

opName	The operation name as it is in the machine file.
inputs	Input value(s) of the operation. Can contain more values than the operation needs, in that case only the first values will be used.
inputsCount	number of inputs
output	The result of the operation.
error	Will not be touched in case of success. Must be freed by the client.

Returns

0 on success, -1 on failure.

Definition at line 286 of file RISCVInstructionExecutor.cc.

                                    {
    if (output == nullptr) {
        if (error != nullptr) {
            *error = strdup(
                "ExecuteInstruction32 error: Output parameter is null");
        }
        return -1;
    }
 
    try {
        std::vector<uint64_t> inputs64(inputsCount);
        for (uint32_t i = 0; i < inputsCount; i++) {
            inputs64[i] = static_cast<uint64_t>(inputs[i]);
        }
 
        std::vector<SimValue> results =
            RISCVInstructionExecutor::executeInstructionHelper(
                opName, 32, inputs64.data(), inputsCount);
        for (size_t i = 0; i < results.size(); i++) {
            output[i] = results.at(i).uIntWordValue();
        }
        return 0;
    } catch (Exception& e) {
        if (error != nullptr) {
            *error = strdup(e.errorMessage().c_str());
        }
        return -1;
    }
}

References Exception::errorMessage(), and RISCVInstructionExecutor::executeInstructionHelper().

Here is the call graph for this function:

executeInstruction64()

int executeInstruction64	(	const char *	opName,
		const uint64_t *	inputs,
		uint32_t	inputsCount,
		uint64_t *	output,
		char **	error
	)

Executes a custom 64-wide instruction.

The instruction behavior is searched automatically by OperationPool from the OSAL search paths. See chapter 4.4 in the manual.

Parameters

opName	The operation name as it is in the machine file.
inputs	Input value(s) of the operation. Can contain more values than the operation needs, in that case only the first values will be used.
inputsCount	number of inputs
output	The result of the operation.
error	Will not be touched in case of success. Must be freed by the client.

Returns

0 on success, -1 on failure.

Definition at line 335 of file RISCVInstructionExecutor.cc.

                                    {
    if (output == nullptr) {
        if (error != nullptr) {
            *error = strdup(
                "ExecuteInstruction64 error: Output parameter is null");
        }
        return -1;
    }
 
    try {
        std::vector<SimValue> results =
            RISCVInstructionExecutor::executeInstructionHelper(
                opName, 64, inputs, inputsCount);
        for (size_t i = 0; i < results.size(); i++) {
            output[i] = results.at(i).uLongWordValue();
        }
        return 0;
    } catch (Exception& e) {
        if (error != nullptr) {
            *error = strdup(e.errorMessage().c_str());
        }
        return -1;
    }
}

References Exception::errorMessage(), and RISCVInstructionExecutor::executeInstructionHelper().

Here is the call graph for this function:

initializeMachine()

int initializeMachine	(	const char *	machinePath,
		char **	error
	)

Initializes the OpenASIP Machine.

Should be called before other functions. Creates the <instruction name, opcode> map for the custom operations, and the OperationPool instruction cache object.

Parameters

machinePath	path to the .adf machine file.
error	error messages in case of failure. Can also be a nullptr if desired. Must be freed by the client.

Returns

0 on success, -1 on failure.

Definition at line 147 of file RISCVInstructionExecutor.cc.

                                                         {
    std::unique_ptr<TTAMachine::Machine> machine = nullptr;
 
    try {
        machine = std::unique_ptr<TTAMachine::Machine>(
            TTAMachine::Machine::loadFromADF(machinePath));
    } catch (const SerializerException& e) {
        if (error != nullptr) {
            std::string errorStr =
                std::string("InitializeMachine error: ") + e.errorMessage();
            *error = strdup(errorStr.c_str());
        }
        return -1;
    }
    BinaryEncoding* bem = BEMGenerator(*machine).generate();
    if (bem == nullptr) {
        *error = strdup("InitializeMachine error: failed to generate bem");
        return -1;
    }
 
    RISCVTools::findCustomOps(RISCVInstructionExecutor::customOps, bem);
    if (RISCVInstructionExecutor::customOps.empty()) {
        *error = strdup(
            "InitializeMachine error: failed to generate custom ops map");
        return -1;
    }
 
    if (RISCVInstructionExecutor::pool == nullptr) {
        RISCVInstructionExecutor::pool = std::make_unique<OperationPool>();
    }
 
    delete bem;
    return 0;
}

References RISCVInstructionExecutor::customOps, Exception::errorMessage(), RISCVTools::findCustomOps(), BEMGenerator::generate(), TTAMachine::Machine::loadFromADF(), machine, and RISCVInstructionExecutor::pool.

Here is the call graph for this function:

resetMachine()

int resetMachine

(

)

Resets the machine to uninitialized state.

Deletes the customOps map loaded and deletes the OperationPool instruction cache.

Definition at line 189 of file RISCVInstructionExecutor.cc.

               {
    RISCVInstructionExecutor::customOps = {};
    RISCVInstructionExecutor::pool = nullptr;
    return 0;
}

References RISCVInstructionExecutor::customOps, and RISCVInstructionExecutor::pool.

unpackInstruction()

int unpackInstruction	(	uint32_t	instruction,
		char **	output,
		char **	error
	)

Unpacks a RISC-V R4-type instruction and returns its string representation if found from the machine file.

Remember to call Initialize machine first.

Parameters

opcode	full RISC-V opcode. Register values are ignored.
output	The char* representation of the opcode, if it is found. Must be freed by the client.
error	Error messages in case of failure. Must be freed by the client.

Returns

0 on success, -1 on failure.

Definition at line 209 of file RISCVInstructionExecutor.cc.

                                                                     {
    if (RISCVInstructionExecutor::customOps.empty()) {
        *error = strdup(
            "UnpackInstruction error: customOps map is empty. Did you "
            "initialize the machine first?");
        return -1;
    }
 
    if (output == nullptr) {
        if (error != nullptr) {
            *error =
                strdup("UnpackInstruction error: Output parameter is null");
        }
        return -1;
    }
 
    R4Instruction decodedInstruction =
        RISCVTools::decodeR4Instruction(instruction);
 
    bool isCustom0 =
        (decodedInstruction.baseopcode ==
         RISCVInstructionExecutor::OPC_CUSTOM_0);
    bool isCustom1 =
        (decodedInstruction.baseopcode ==
         RISCVInstructionExecutor::OPC_CUSTOM_1);
 
    if (!isCustom0 && !isCustom1) {
        if (error != nullptr) {
            *error = strdup("UnpackInstruction error: Unknown base opcode");
        }
        return -1;
    }
 
    std::string opName = "";
    for (const auto& op : RISCVInstructionExecutor::customOps) {
        uint32_t encoding = op.second;
        bool isMatch = false;
 
        if (isCustom1 &&
            RISCVTools::getFunc2Int(encoding) == decodedInstruction.funct2 &&
            RISCVTools::getFunc3Int(encoding) == decodedInstruction.funct3) {
            isMatch = true;
        } else if (
            isCustom0 &&
            RISCVTools::getFunc7Int(encoding) == decodedInstruction.funct7 &&
            RISCVTools::getFunc3Int(encoding) == decodedInstruction.funct3) {
            isMatch = true;
        }
 
        if (isMatch) {
            *output = strdup(op.first.c_str());
            return 0;
        }
    }
 
    if (error != nullptr) {
        *error = strdup("UnpackInstruction error: Operation not found");
    }
    return -1;
}

References R4Instruction::baseopcode, RISCVInstructionExecutor::customOps, RISCVTools::decodeR4Instruction(), R4Instruction::funct2, R4Instruction::funct3, R4Instruction::funct7, RISCVTools::getFunc2Int(), RISCVTools::getFunc3Int(), RISCVTools::getFunc7Int(), RISCVInstructionExecutor::OPC_CUSTOM_0, and RISCVInstructionExecutor::OPC_CUSTOM_1.

Here is the call graph for this function: