Decoder.h

/**
 * @class Decoder
 * @brief Decodes raw 32 bit RISC-V instructions into structured fields.
 *
 * This class provides functionality to decode different types of RISC-V
 * instructions (R,I,S,B,U,J types) into a common structured format
 * for easier instruction execution by the CPU emulator.
 */

#pragma once
#include <iostream>
#include <cstdint>
#include <string>
#include <array>


class Decoder {
public:

    /**
     * @struct DecodedInstr
     * @brief Represents a fully decoded RISC-V instruction.
     *
     * Contains all relevant fields extracted from the instruction word,
     * including opcode, function codes, registers, immediate value, and
     * instruction format type.
     */
    struct DecodedInstr {
        uint8_t opcode;      // Opcode field identifying instruction type
        uint8_t funct3;      // 3 bit function field used for further opcode decoding
        uint8_t funct7;      // 7 bit function field for R type instructions
        uint8_t rd;          // Destination register index
        uint8_t rs1;         // Source register 1 
        uint8_t rs2;         // Source register 2 
        int32_t imm;         // Sign extended immediate
        std::string type;    // Instruction format type

        /**
         * @brief Constructs a DecodedInstr with optional default values.
         * @param op Opcode
         * @param f3 funct3 
         * @param f7 funct7
         * @param dr Destination register
         * @param s1 Source register 1
         * @param s2 Source register 2
         * @param imm Immediate value
         * @param type Instruction format type string
         */
        DecodedInstr(uint8_t op = 0, uint8_t f3 = 0, uint8_t f7 = 0, uint8_t dr = 0,
            uint8_t s1 = 0, uint8_t s2 = 0, int32_t imm = 0, std::string type = "")
            : opcode(op), funct3(f3), funct7(f7), rd(dr), rs1(s1), rs2(s2), imm(imm), type(std::move(type)) {
        }
    };

    enum InstrType {
        R_TYPE,
        I_TYPE,
        S_TYPE,
        B_TYPE,
        U_TYPE,
        J_TYPE,
        ECALL_TYPE,
        JALR_TYPE,
        UNKNOWN_TYPE
    };


    using DecodeFunc = DecodedInstr(*)(uint32_t);

    /**
     * @brief Constructor for the Decoder that initializes the decoder table.
     */
    Decoder();

    /**
     * @brief Decodes a 32 bit instruction into a structured DecodedInstr.
     * @param instr 32 bit instruction word.
     * @return DecodedInstr struct containing decoded fields.
     */
    DecodedInstr decode(uint32_t instr);

    /**
    * @brief Sign extends a integer to a 32 bit signed integer.
    *
    * Extends the sign integer at the specified bit width to the full 32 bits.
    *
    * @param value The original unsigned bit value.
    * @param bitWidth The bit position of the sign bit
    * @return The sign extended 32 bit signed integer.
    */
    static int32_t signExtend(uint32_t value, int bitWidth);


private:

    DecodeFunc decodeTable[128] = {}; // Function pointer table indexed by opcode for decoding

   
    /**
     * @brief Initializes the decodeTable mapping opcodes to decode functions.
     */
    void initDecodeTable();

    // Static decoding functions for each instruction format:
    static DecodedInstr decodeR(uint32_t instr);
    static DecodedInstr decodeI(uint32_t instr);
    static DecodedInstr decodeS(uint32_t instr);
    static DecodedInstr decodeB(uint32_t instr);
    static DecodedInstr decodeU(uint32_t instr);
    static DecodedInstr decodeJ(uint32_t instr);
};