diff options
| -rw-r--r-- | inc/definitions.h | 6 | ||||
| -rw-r--r-- | inc/ex.h | 18 | ||||
| -rw-r--r-- | inc/instr.h | 1 | ||||
| -rw-r--r-- | inc/stage.h | 18 | ||||
| -rw-r--r-- | src/sim/ex.cc | 88 | ||||
| -rw-r--r-- | src/sim/instr.cc | 29 | ||||
| -rw-r--r-- | src/sim/stage.cc | 12 |
7 files changed, 141 insertions, 31 deletions
diff --git a/inc/definitions.h b/inc/definitions.h index 3238a8b..c81c4e3 100644 --- a/inc/definitions.h +++ b/inc/definitions.h @@ -77,6 +77,12 @@ #define OPCODE_SIZE 4 /** + * The maximum value an integer can hold. + * The minimum is always this number plus one negated. + */ +#define MAX_INT 2147483647 + +/** * Return the N least-significant bits from integer K using a bit mask * @param the integer to be parsed * @param the number of bits to be parsed @@ -3,6 +3,7 @@ #include "instrDTO.h" #include "response.h" #include "stage.h" +#include <unordered_map> class EX : public Stage { @@ -15,6 +16,23 @@ class EX : public Stage EX(Stage *next); InstrDTO *advance(Response p) override; + + private: + /** + * Sets the (over|under)flow condition code if adding `a` and `b` results in + * either. + * @param the first operand + * @param the second operand + */ + void overflow_guard(signed int a, signed int b); + /** + * Maps each mnemonic to a function which carries out the instruction's base + * logic. + */ + std::unordered_map< + Mnemonic, + std::function<void(signed int &s1, signed int &s2)>> + instr_map; }; #endif /* EX_H_INCLUDED */ diff --git a/inc/instr.h b/inc/instr.h index 08b4fd0..7fbb42b 100644 --- a/inc/instr.h +++ b/inc/instr.h @@ -49,7 +49,6 @@ namespace instr { // clang-format off extern const std::unordered_map<unsigned int, Mnemonic> mnemonic_map; - extern const std::unordered_map<Mnemonic, std::function<void(signed int &s1, signed int &s2, signed int &s3)>> instr_map; // clang-format on } // namespace instr diff --git a/inc/stage.h b/inc/stage.h index 50c413a..c0dc6a8 100644 --- a/inc/stage.h +++ b/inc/stage.h @@ -9,6 +9,13 @@ #include <deque> #include <memory> +enum CC { + GT, + EQ, + UF, + OF, +}; + class Stage { public: @@ -31,6 +38,17 @@ class Stage protected: /** + * Sets the bit in the condition code register corresponding to `c`. + * @param the condition code to set. + * @param the truthy value to set it to. + */ + void set_condition(CC c, bool v); + /** + * Gets the bit in the condition code register correspondng to `c`. + * @param the condition code to retrieve, + */ + bool get_condition(CC c); + /** * Helper for `check_out`. * Returns true if r are not checked out, false otherwise. * @param a list of register numbers. diff --git a/src/sim/ex.cc b/src/sim/ex.cc index 3a1e92c..fbf460f 100644 --- a/src/sim/ex.cc +++ b/src/sim/ex.cc @@ -1,9 +1,95 @@ #include "ex.h" #include "accessor.h" +#include "definitions.h" #include "instrDTO.h" #include "response.h" #include "stage.h" +#include <unordered_map> -EX::EX(Stage *stage) : Stage(stage) { this->id = EXEC; } +// clang-format off +#define INIT_INSTRUCTION(mnemonic, body) \ + {mnemonic, [this](signed int &s1, signed int &s2) { \ + body; \ + }} +// clang-format on + +EX::EX(Stage *stage) : Stage(stage) +{ + this->id = EXEC; + instr_map = { + + /* R type instructions */ + INIT_INSTRUCTION( + ADD, + { + this->overflow_guard(s1, s2); + s1 = s1 + s2; + }), + + INIT_INSTRUCTION( + SUB, + { + this->overflow_guard(s1, -s2); + s1 = s1 - s2; + }), + + INIT_INSTRUCTION(MUL, {}), + INIT_INSTRUCTION(QUOT, {}), + INIT_INSTRUCTION(REM, {}), + INIT_INSTRUCTION(SFTR, {}), + INIT_INSTRUCTION(SFTL, {}), + INIT_INSTRUCTION(AND, {}), + INIT_INSTRUCTION(OR, {}), + INIT_INSTRUCTION(NOT, {}), + INIT_INSTRUCTION(XOR, {}), + INIT_INSTRUCTION(ADDV, {}), + INIT_INSTRUCTION(SUBV, {}), + INIT_INSTRUCTION(MULV, {}), + INIT_INSTRUCTION(DIVV, {}), + INIT_INSTRUCTION(CMP, {}), + INIT_INSTRUCTION(CEV, {}), + + /* I type instructions */ + INIT_INSTRUCTION(LOAD, {}), + INIT_INSTRUCTION(LOADV, {}), + INIT_INSTRUCTION(ADDI, {}), + INIT_INSTRUCTION(SUBI, {}), + INIT_INSTRUCTION(SFTRI, {}), + INIT_INSTRUCTION(SFTL, {}), + INIT_INSTRUCTION(ANDI, {}), + INIT_INSTRUCTION(ORI, {}), + INIT_INSTRUCTION(XORI, {}), + INIT_INSTRUCTION(STORE, {}), + INIT_INSTRUCTION(STOREV, {}), + + /* J type instructions */ + INIT_INSTRUCTION(JMP, {}), + INIT_INSTRUCTION(JRL, {}), + INIT_INSTRUCTION(JAL, {}), + INIT_INSTRUCTION(BEQ, {}), + INIT_INSTRUCTION(BGT, {}), + INIT_INSTRUCTION(BUF, {}), + INIT_INSTRUCTION(BOF, {}), + INIT_INSTRUCTION(PUSH, {}), + INIT_INSTRUCTION(POP, {}), + + /* NOP */ + INIT_INSTRUCTION(NOP, (void)s2; (void)s1;), + }; +} InstrDTO *EX::advance(Response p) { return nullptr; } + +void EX::overflow_guard(signed int a, signed int b) +{ + if (a >= 0 && b >= 0 && (a > MAX_INT - b)) { + this->set_condition(OF, true); + this->set_condition(UF, false); + } else if (a < 0 && b < 0 && (a < (-MAX_INT) - 1 - b)) { + this->set_condition(OF, false); + this->set_condition(UF, true); + } else { + this->set_condition(OF, false); + this->set_condition(UF, false); + } +} diff --git a/src/sim/instr.cc b/src/sim/instr.cc index 08edf5e..e614de5 100644 --- a/src/sim/instr.cc +++ b/src/sim/instr.cc @@ -3,36 +3,8 @@ #include <map> #include <unordered_map> -// clang-format off -#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::unordered_map<Mnemonic, std::function<void(signed int &s1, signed int &s2, signed int &s3)>> - // clang-format on - instr_map = { - - /* R type instructions */ - // TODO these need to be WRAPPED with a function that sets overflow. - // future note to self, if these are more than 2 lines each, you're - // doing it wrong - INIT_INSTRUCTION(ADD, s3 = s1 + s2;), - INIT_INSTRUCTION(SUB, s3 = s1 - s2;), - - /* I type instructions */ - - /* J type instructions */ - - /* NOP */ - INIT_INSTRUCTION(NOP, (void)s3; (void)s2; (void)s1;), - -}; - const std::unordered_map<unsigned int, Mnemonic> mnemonic_map = { {0b0000100, ADD}, {0b0001000, SUB}, {0b0001100, MUL}, {0b0010000, QUOT}, {0b0010100, REM}, {0b0011000, SFTR}, @@ -48,6 +20,5 @@ const std::unordered_map<unsigned int, Mnemonic> mnemonic_map = { {0b0001010, JRL}, {0b0001110, JAL}, {0b0010010, BEQ}, {0b0010110, BGT}, {0b0011010, BUF}, {0b0011110, BOF}, {0b0100010, PUSH}, {0b0100110, POP}, - }; } // namespace instr diff --git a/src/sim/stage.cc b/src/sim/stage.cc index 62a7fd6..d8c882a 100644 --- a/src/sim/stage.cc +++ b/src/sim/stage.cc @@ -21,6 +21,18 @@ Storage *Stage::storage; bool Stage::is_pipelined; int Stage::clock_cycle; +void Stage::set_condition(CC c, bool v) +{ + if (v) + this->gprs[3] = this->gprs[3] & 1 << c; + else + this->gprs[3] = this->gprs[3] & ~(1 << c); +} + +bool Stage::get_condition(CC c) { + return (this->gprs[3] >> c) & 1; +} + signed int Stage::dereference_register(signed int v) { signed int r; |