RISCVTools.icc

Go to the documentation of this file.

/*
 Copyright (C) 2024 Tampere University.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */
/**
 * @file RISCVTools.icc
 *
 * Implementation of RISCVTools class.
 *
 * @author Kari Hepola 2024 (kari.hepola@tuni.fi)
 * @note rating: red
 */
 
#include <bitset>
#include "MapTools.hh"
 
inline int
RISCVTools::getFunc3Int(const int encoding) {
    const int mask = 0b1110000000;
    const int enc = ((encoding & mask) >> 7);
    return enc;
}
 
inline int
RISCVTools::getFunc7Int(const int encoding) {
    const int mask = 0b11111110000000000;
    const int enc = ((encoding & mask) >> 10);
    return enc;
}
 
inline int
RISCVTools::getFunc2Int(const int encoding) {
    const int mask = 0b11000000000000000;
    const int enc = ((encoding & mask) >> 15);
    return enc;
}
 
inline int
RISCVTools::getOpcodeInt(const int encoding) {
    const int mask = 0b1111111;
    const int enc = encoding & mask;
    return enc;
}
 
inline std::string
RISCVTools::getFunc3Str(const int encoding) {
    const int enc = getFunc3Int(encoding);
    const std::string encStr = std::bitset<3>(enc).to_string();
    assert(encStr.length() == 3);
    return "0b" + encStr;
}
 
 
inline std::string
RISCVTools::getFunc7Str(const int encoding) {
    const int enc = getFunc7Int(encoding);
    const std::string encStr = std::bitset<7>(enc).to_string();
    assert(encStr.length() == 7);
    return "0b" + encStr;
}
 
inline std::string
RISCVTools::getFunc2Str(const int encoding) {
    const int enc = getFunc7Int(encoding);
    const std::string encStr = std::bitset<2>(enc).to_string();
    assert(encStr.length() == 2);
    return "0b" + encStr;
}
 
inline std::string
RISCVTools::getOpcodeStr(const int encoding) {
    const int enc = getOpcodeInt(encoding);
    const std::string encStr = std::bitset<7>(enc).to_string();
    assert(encStr.length() == 7);
    return "0b" + encStr;
}
 
void
RISCVTools::findCustomOps(std::map<std::string, int>& customOps_, BinaryEncoding* bem_) {
    customOps_.clear();
    const std::vector<std::string> formatsToSearch = {
        RISCVFields::RISCV_R_TYPE_NAME,
        RISCVFields::RISCV_R1R_TYPE_NAME,
        RISCVFields::RISCV_R1_TYPE_NAME,
        RISCVFields::RISCV_R3R_TYPE_NAME
    };
    for (const std::string& fName : formatsToSearch) {
        InstructionFormat* format = bem_->instructionFormat(fName);
        if (format == NULL) {
            continue;
        }
        for (int i = 0; i < format->operationCount(); i++) {
            const std::string op = format->operationAtIndex(i);
            if (!MapTools::containsKey(RISCVFields::RISCVRTypeOperations, op)) {
                customOps_.insert({op, format->encoding(op)});
            }
        }
    }
}
 
/**
 * @param instruction the whole opcode, as it is found in the objdump
 * @return Struct of decoded values. Register values are discarded.
 */
inline R4Instruction
RISCVTools::decodeR4Instruction(const uint32_t instruction) {
    int baseopcode = instruction & 0x7F;
    int funct3 = (instruction >> 12) & 0x7;
    int funct7 = (instruction >> 25) & 0x7F;
    int funct2 = (instruction >> 25) & 0x3;
    return {baseopcode, funct3, funct7, funct2};
}