From 9cd1f287f0c86b36788cd8ede812b847c584f711 Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 28 Mar 2025 18:10:14 -0400 Subject: add get_instr_fields func to parse instruction fields from raw bits --- src/utils/utils.cc | 59 +++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 54 insertions(+), 5 deletions(-) (limited to 'src/utils/utils.cc') diff --git a/src/utils/utils.cc b/src/utils/utils.cc index 3a11c2c..3b140e0 100644 --- a/src/utils/utils.cc +++ b/src/utils/utils.cc @@ -4,14 +4,62 @@ #include #include -void get_bit_fields(int address, int *tag, int *index, int *offset) +static Logger *global_log = Logger::getInstance(); + +void get_cache_fields(int address, int *tag, int *index, int *offset) { - *tag = GET_MID_BITS( - address, L1_CACHE_LINE_SPEC + LINE_SPEC, MEM_WORD_SPEC); + *tag = GET_MID_BITS(address, L1_CACHE_LINE_SPEC + LINE_SPEC, MEM_WORD_SPEC); *index = GET_MID_BITS(address, LINE_SPEC, L1_CACHE_LINE_SPEC + LINE_SPEC); *offset = GET_LS_BITS(address, LINE_SPEC); } +void get_instr_fields( + signed int &s1, + signed int &s2, + signed int &s3, + unsigned int &type, + unsigned int &opcode) +{ + type = GET_LS_BITS(s1, TYPE_SIZE); + switch (type) { + case 0: + // R-TYPE + opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + R_OPCODE_SIZE); + s3 = GET_MID_BITS( + s1, TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 2), + TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 3)); + s2 = GET_MID_BITS( + s1, TYPE_SIZE + R_OPCODE_SIZE + REG_SIZE, + TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 2)); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + R_OPCODE_SIZE, + TYPE_SIZE + R_OPCODE_SIZE + REG_SIZE); + break; + case 1: + // I-TYPE + opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + OPCODE_SIZE); + s3 = GET_MID_BITS( + s1, TYPE_SIZE + OPCODE_SIZE + (REG_SIZE * 2), WORD_SPEC); + s2 = GET_MID_BITS( + s1, TYPE_SIZE + OPCODE_SIZE + REG_SIZE, + TYPE_SIZE + OPCODE_SIZE + (REG_SIZE * 2)); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + OPCODE_SIZE, TYPE_SIZE + OPCODE_SIZE + REG_SIZE); + break; + case 2: + // J-TYPE + opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + OPCODE_SIZE); + s2 = GET_MID_BITS(s1, TYPE_SIZE + OPCODE_SIZE + REG_SIZE, WORD_SPEC); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + OPCODE_SIZE, TYPE_SIZE + OPCODE_SIZE + REG_SIZE); + break; + default: + global_log->log( + DEBUG, + string_format("%s returning invalid type: %d", __FUNCTION__, type)); + } +} + const std::string string_format(const char *const zcFormat, ...) { va_list vaArgs; @@ -28,8 +76,9 @@ const std::string string_format(const char *const zcFormat, ...) return std::string(zc.data(), iLen); } -int wrap_address(int address) { - if (address < 0){ +int wrap_address(int address) +{ + if (address < 0) { return ((address % MEM_WORDS) + MEM_WORDS) % MEM_WORDS; } return address % MEM_WORDS; -- cgit v1.2.3 From 7b3abbd51c91b51725a12d17fad6ecbfcdb19975 Mon Sep 17 00:00:00 2001 From: bd Date: Fri, 28 Mar 2025 19:55:04 -0400 Subject: Move get_instr_fields, add all instruction mnemonics --- inc/id.h | 18 +++++++++ inc/instr.h | 47 ++++++++++++++++++++++- inc/storage.h | 2 +- inc/utils.h | 18 --------- src/sim/id.cc | 58 +++++++++++++++++++++++++++- src/sim/instr.cc | 27 +++++++++++--- src/utils/utils.cc | 49 ------------------------ tests/utils.cc | 108 ----------------------------------------------------- 8 files changed, 142 insertions(+), 185 deletions(-) (limited to 'src/utils/utils.cc') diff --git a/inc/id.h b/inc/id.h index eafe274..1503457 100644 --- a/inc/id.h +++ b/inc/id.h @@ -15,6 +15,24 @@ class ID : public Stage ID(Stage *next); Response advance(InstrDTO &i) override; + + /** + * Parse an instruction into a type, opcode, and fields. If the type is + * invalid, only the type field will be set. + * @param the resulting first field, which varies per type. To call this + * function properly, this field must contain the full instruction bytes on + * function entry. + * @param the resulting second field, which varies per type. + * @param the resulting third field, which varies per type. + * @param the resulting type. + * @param the resulting opcode. + */ + void get_instr_fields( + signed int &s1, + signed int &s2, + signed int &s3, + unsigned int &type, + unsigned int &opcode); }; #endif /* ID_D_INCLUDED */ diff --git a/inc/instr.h b/inc/instr.h index ce08685..98ecf1d 100644 --- a/inc/instr.h +++ b/inc/instr.h @@ -1,13 +1,56 @@ #ifndef INSTR_H #define INSTR_H - #include +#include #include +enum Mnemonic { + ADD, + SUB, + MUL, + QUOT, + REM, + SFTR, + SFTL, + AND, + OR, + NOT, + XOR, + ADDV, + SUBV, + MULV, + DIVV, + CMP, + CEV, + LOAD, + LOADV, + ADDI, + SUBI, + SFTRI, + SFTLI, + ANDI, + ORI, + XORI, + STORE, + STOREV, + JMP, + JRL, + JAL, + BEQ, + BGT, + BUF, + BOF, + PUSH, + POP, +}; + +std::ostream &operator<<(std::ostream &os, Mnemonic a); + namespace instr { // clang-format off -extern const std::map>> instr_map; + extern const std::map mnemonic_map; + extern const std::map> instr_map; // clang-format on } // namespace instr diff --git a/inc/storage.h b/inc/storage.h index ff1fbcb..d6fa094 100644 --- a/inc/storage.h +++ b/inc/storage.h @@ -80,7 +80,7 @@ class Storage /** * The accessor currently being serviced. */ - enum Accessor requester; + Accessor requester; /** * The number of cycles until the current request is completed. */ diff --git a/inc/utils.h b/inc/utils.h index 7fed157..a375b68 100644 --- a/inc/utils.h +++ b/inc/utils.h @@ -12,24 +12,6 @@ */ void get_cache_fields(int address, int *tag, int *index, int *offset); -/** - * Parse an instruction into a type, opcode, and fields. If the type is invalid, - * only the type field will be set. - * @param the resulting first field, which varies per type. To call this - * function properly, this field must contain the full instruction bytes on - * function entry. - * @param the resulting second field, which varies per type. - * @param the resulting third field, which varies per type. - * @param the resulting type. - * @param the resulting opcode. - */ -void get_instr_fields( - signed int &s1, - signed int &s2, - signed int &s3, - unsigned int &type, - unsigned int &opcode); - /** * Formats a string using snprintf. * @param an object that represents the format string diff --git a/src/sim/id.cc b/src/sim/id.cc index 87dce0c..65acef5 100644 --- a/src/sim/id.cc +++ b/src/sim/id.cc @@ -1,9 +1,65 @@ #include "id.h" #include "accessor.h" #include "instrDTO.h" +#include "logger.h" #include "response.h" #include "stage.h" +#include "utils.h" + +static Logger *global_log = Logger::getInstance(); ID::ID(Stage *stage) : Stage(stage) { this->id = DCDE; } -Response ID::advance(InstrDTO &i) { return OK; } +Response ID::advance(InstrDTO &i) { Response r; } + +void ID::get_instr_fields( + signed int &s1, + signed int &s2, + signed int &s3, + unsigned int &type, + unsigned int &opcode) +{ + // unsigned int &opcode; + int opcode_bits; + + type = GET_LS_BITS(s1, TYPE_SIZE); + opcode_bits = (type == 0b0) ? R_OPCODE_SIZE : OPCODE_SIZE; + + switch (type) { + case 0: + // R-TYPE + opcode += GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + opcode_bits); + s3 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits + (REG_SIZE * 2), + TYPE_SIZE + opcode_bits + (REG_SIZE * 3)); + s2 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits + REG_SIZE, + TYPE_SIZE + opcode_bits + (REG_SIZE * 2)); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits, + TYPE_SIZE + opcode_bits + REG_SIZE); + break; + case 1: + // I-TYPE + opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + opcode_bits); + s3 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits + (REG_SIZE * 2), WORD_SPEC); + s2 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits + REG_SIZE, + TYPE_SIZE + opcode_bits + (REG_SIZE * 2)); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + opcode_bits, TYPE_SIZE + opcode_bits + REG_SIZE); + break; + case 2: + // J-TYPE + opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + opcode_bits); + s2 = GET_MID_BITS(s1, TYPE_SIZE + OPCODE_SIZE + REG_SIZE, WORD_SPEC); + s1 = GET_MID_BITS( + s1, TYPE_SIZE + OPCODE_SIZE, TYPE_SIZE + OPCODE_SIZE + REG_SIZE); + break; + default: + global_log->log( + DEBUG, + string_format("%s returning invalid type: %d", __FUNCTION__, type)); + } +} diff --git a/src/sim/instr.cc b/src/sim/instr.cc index 608b871..50aa71d 100644 --- a/src/sim/instr.cc +++ b/src/sim/instr.cc @@ -3,16 +3,16 @@ #include // clang-format off -#define INIT_INSTRUCTION(type, opcode, body) \ - {type, {{opcode, [](signed int &s1, signed int &s2, signed int &s3) { \ +#define INIT_INSTRUCTION(mnemonic, body) \ + {mnemonic, [](signed int &s1, signed int &s2, signed int &s3) { \ body; \ - }}}} + }} // clang-format on namespace instr { // clang-format off -const std::map>> +const std::map> // clang-format on instr_map = { @@ -20,11 +20,26 @@ const std::map mnemonic_map = { + {0b0000100, ADD}, {0b0001000, SUB}, {0b0001100, MUL}, {0b0010000, QUOT}, + {0b0010100, REM}, {0b0011000, SFTR}, {0b0011100, SFTL}, {0b0100000, AND}, + {0b0100100, OR}, {0b0101000, NOT}, {0b0101100, XOR}, {0b0110000, ADDV}, + {0b0110100, SUBV}, {0b0111000, MULV}, {0b0111100, DIVV}, {0b1000000, CMP}, + {0b1000100, CEV}, {0b000101, LOAD}, {0b001001, LOADV}, {0b001101, ADDI}, + {0b010001, SUBI}, {0b010101, SFTRI}, {0b011101, SFTLI}, {0b100001, ANDI}, + {0b100101, ORI}, {0b101001, XORI}, {0b101101, STORE}, {0b110001, STOREV}, + {0b000101, CEV}, {0b000101, LOAD}, {0b001001, LOADV}, {0b001001, LOADV}, + {0b000110, JMP}, {0b001010, JRL}, {0b001110, JAL}, {0b010010, BEQ}, + {0b010110, BGT}, {0b011010, BUF}, {0b011110, BOF}, {0b100010, PUSH}, + {0b100110, POP}, + +}; } // namespace instr diff --git a/src/utils/utils.cc b/src/utils/utils.cc index 3b140e0..e12a0e0 100644 --- a/src/utils/utils.cc +++ b/src/utils/utils.cc @@ -4,8 +4,6 @@ #include #include -static Logger *global_log = Logger::getInstance(); - void get_cache_fields(int address, int *tag, int *index, int *offset) { *tag = GET_MID_BITS(address, L1_CACHE_LINE_SPEC + LINE_SPEC, MEM_WORD_SPEC); @@ -13,53 +11,6 @@ void get_cache_fields(int address, int *tag, int *index, int *offset) *offset = GET_LS_BITS(address, LINE_SPEC); } -void get_instr_fields( - signed int &s1, - signed int &s2, - signed int &s3, - unsigned int &type, - unsigned int &opcode) -{ - type = GET_LS_BITS(s1, TYPE_SIZE); - switch (type) { - case 0: - // R-TYPE - opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + R_OPCODE_SIZE); - s3 = GET_MID_BITS( - s1, TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 2), - TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 3)); - s2 = GET_MID_BITS( - s1, TYPE_SIZE + R_OPCODE_SIZE + REG_SIZE, - TYPE_SIZE + R_OPCODE_SIZE + (REG_SIZE * 2)); - s1 = GET_MID_BITS( - s1, TYPE_SIZE + R_OPCODE_SIZE, - TYPE_SIZE + R_OPCODE_SIZE + REG_SIZE); - break; - case 1: - // I-TYPE - opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + OPCODE_SIZE); - s3 = GET_MID_BITS( - s1, TYPE_SIZE + OPCODE_SIZE + (REG_SIZE * 2), WORD_SPEC); - s2 = GET_MID_BITS( - s1, TYPE_SIZE + OPCODE_SIZE + REG_SIZE, - TYPE_SIZE + OPCODE_SIZE + (REG_SIZE * 2)); - s1 = GET_MID_BITS( - s1, TYPE_SIZE + OPCODE_SIZE, TYPE_SIZE + OPCODE_SIZE + REG_SIZE); - break; - case 2: - // J-TYPE - opcode = GET_MID_BITS(s1, TYPE_SIZE, TYPE_SIZE + OPCODE_SIZE); - s2 = GET_MID_BITS(s1, TYPE_SIZE + OPCODE_SIZE + REG_SIZE, WORD_SPEC); - s1 = GET_MID_BITS( - s1, TYPE_SIZE + OPCODE_SIZE, TYPE_SIZE + OPCODE_SIZE + REG_SIZE); - break; - default: - global_log->log( - DEBUG, - string_format("%s returning invalid type: %d", __FUNCTION__, type)); - } -} - const std::string string_format(const char *const zcFormat, ...) { va_list vaArgs; diff --git a/tests/utils.cc b/tests/utils.cc index 6c72694..2e0e934 100644 --- a/tests/utils.cc +++ b/tests/utils.cc @@ -22,114 +22,6 @@ TEST_CASE("Parse arbitrary fields # two", "[utils]") CHECK(offset == 0b11); } -TEST_CASE("Parse invalid type", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0x00FF00FF; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b11); - // behavior does nothing - CHECK(s1 == 0x00FF00FF); - CHECK(s2 == 0b0); - CHECK(s3 == 0b0); - CHECK(opcode == 0b0); -} - -TEST_CASE("Parse arbitrary r-type # one", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0xCCCCCCCC; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b00); - CHECK(s1 == 0b11001); - CHECK(s2 == 0b01100); - CHECK(s3 == 0b00110); - CHECK(opcode == 0b10011); -} - -TEST_CASE("Parse arbitrary r-type # two", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0x99AABBCC; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b00); - CHECK(s1 == 0b10111); - CHECK(s2 == 0b01011); - CHECK(s3 == 0b10101); - CHECK(opcode == 0b10011); -} - -TEST_CASE("Parse arbitrary i-type # one", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0xDDDDDDDD; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b01); - CHECK(s1 == 0b10111); - CHECK(s2 == 0b11011); - CHECK(s3 == 0xDDDD); - CHECK(opcode == 0b0111); -} - -TEST_CASE("Parse arbitrary i-type # two", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0xAABBCCDD; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b01); - CHECK(s1 == 0b10011); - CHECK(s2 == 0b11001); - CHECK(s3 == 0xAABB); - CHECK(opcode == 0b0111); -} - -TEST_CASE("Parse arbitrary j-type # one", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0xEEEEEEEE; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b10); - CHECK(s1 == 0b11011); - CHECK(s2 == 0b111011101110111011101); - CHECK(opcode == 0b1011); - // behavior does nothing - CHECK(s3 == 0b0); -} - -TEST_CASE("Parse arbitrary j-type # two", "[utils]") -{ - signed int s1 = 0, s2 = 0, s3 = 0; - unsigned int type = 0, opcode = 0; - - s1 = 0xBBCCDDEE; - get_instr_fields(s1, s2, s3, type, opcode); - - REQUIRE(type == 0b10); - CHECK(s1 == 0b10111); - CHECK(s2 == 0b101110111100110011011); - CHECK(opcode == 0b1011); - // behavior does nothing - CHECK(s3 == 0b0); -} - TEST_CASE("wrap address outside upper bound", "[utils]") { int address = MEM_WORDS + 25; -- cgit v1.2.3