-
Notifications
You must be signed in to change notification settings - Fork 0
/
instructions.h
103 lines (72 loc) · 2.23 KB
/
instructions.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#ifndef INSTRUCTIONS_H_
#define INSTRUCTIONS_H_
#include <map>
#include <iterator>
#include <iostream>
#include <string.h>
#include "pipeline.h"
#define INST_SIZE 32
#define OP_SIZE 6
#define REG_REF_SIZE 5
#define REG_EMPTY -1
#define OPCODE(X) ((opcode_t)((X & 0xFC000000) >> (INST_SIZE-OP_SIZE)))
class BranchException : public std::exception {//thrown when there is nothing left for instruction to do
const char * what() const throw(){
return "";// "Branch\n";
}
};
class InstructionEmpty : public std::exception {//thrown when there is nothing left for instruction to do
const char * what() const throw(){
return "";// "Instruction empty\n";
}
};
class EndOfProgram : public std::exception {//thrown when there is nothing left for instruction to do
const char * what() const throw(){
return "";// "Program over!\n"; // "Instruction empty\n";
}
};
class Instruction { //super class that shows all data types and functions an instruction must have
protected:
std::string type;
int bit_inst;
Pipeline * pl;
unsigned pc_init;
unsigned rob_entry;
unsigned RSU_entry;
reg_t data_type;
stage_t stage;
int immediate;
unsigned int RD;
unsigned int RS;
unsigned int RT;
unsigned arith_result;
public:
Instruction(int bit_inst, Pipeline * pl);
//Assess() handles the proper, sequential execution of each instruction phase
//does not advance to the next stage if exception is thrown
void assess();
void setStage(stage_t stage);
stage_t getStage();
unsigned getPC();
//pipeline stages
virtual void issue();
virtual void execute();
virtual void write_result();
virtual void commit();
void print();
};
typedef Instruction* (*CreateInstFn)(int bit_inst, Pipeline * pl); //funct pointer to class creator
class Instruction_Factory{
private:
Instruction_Factory();
Instruction_Factory(const Instruction_Factory &){}
Instruction_Factory &operator=(const Instruction_Factory &) { return *this; } //overload '='
typedef std::map<const opcode_t, CreateInstFn> FactoryMap;
FactoryMap m_FactoryMap;
public:
~Instruction_Factory();
static Instruction_Factory *Get();
void Register(const opcode_t type, CreateInstFn pfnCreate);
Instruction *Create_Instruction(const opcode_t type, int bit_inst, Pipeline * pl);
};
#endif