3b_sim/ccpu.cpp

   1 #include "ccpu.hpp"
   2
   3 /*              CDat m_pc, m_pc_next;
   4                 CMem m_regfile, m_ram;
   5 */
   6
   7 //void registerExtension() {};
   8
   9 const char* expression = "(;.*)|(r0)|(rX)|(r1[0-5])|(r[1-5])|(r[6-9])|(0x[a-fA-F0-9]+)|([-]?\\d+)";
  10 const char* format = "(?1$&)"
  11                                         //Return-Register: violett
  12                                         "(?2\033[0m\033[35m$&\033[0m\\3:)"
  13                                         // Callee-saved Register: rot
  14                                         "(?4\033[0m\033[31m$&\033[0m\\3:)"
  15                                         //Argument-Register: gruen
  16                                         "(?5\033[0m\033[32m$&\033[0m\\3:)"
  17                                         // Temporary Register: gelb
  18                                         "(?6\033[0m\033[33m$&\033[0m\\3:)"
  19                                         // Zahlenwerte: tuerkis
  20                                         "(?7\033[0m\033[36m$&\033[0m\\3:)"
  21                                         "(?8\033[0m\033[36m$&\033[0m\\3:)";
  22
  23
  24 string CCpu::colorifyInstr(string instr)
  25 {
  26         boost::regex e;
  27         e.assign(expression);
  28         return boost::regex_replace(instr, e, format, boost::match_default | boost::format_all);
  29 }
  30
  31 void CCpu::registerExtension(Iext* ext)
  32 {
  33         m_exts.push_back(ext);
  34 }
  35
  36 void CCpu::tick()
  37 {
  38         // signal extensions
  39         // Todo
  40
  41         m_pc = m_pc_next;
  42         m_pc_next += 4;
  43         Iinstr* instr = this->getProg(m_pc);
  44
  45         if(instr == NULL) {
  46                 throw string("Out of Instructions!");
  47         }
  48
  49         for(auto iter = m_exts.begin(); iter != m_exts.end(); ++iter) {
  50                 (*iter)->applyTick();
  51         }
  52
  53         if(this->conditionMet(instr->getCondition())) {
  54                 cout << color(green,black) << "Executing: " << color(white,black) << colorifyInstr(instr->toString()) << endl;
  55                 instr->execInstr();
  56                 this->incPerfBy(instr->getClockCount());
  57         }
  58         else {
  59                 cout << color(red,black) << "Didn't Execute " << color(white,black) << colorifyInstr(instr->toString()) << "; condition wasn't met" << endl;
  60                 this->incPerf();
  61         }
  62
  63 }
  64
  65 bool CCpu::conditionMet(short cond)
  66 {
  67         switch(cond) {
  68                 case NOT_EQUAL:
  69                         return !this->m_Z;
  70                         break;
  71                 case EQUAL:
  72                         return this->m_Z;
  73                         break;
  74                 case NOT_OVERFLOW:
  75                         return !this->m_O;
  76                         break;
  77                 case OVER_FLOW:
  78                         return this->m_O;
  79                         break;
  80                 case NOT_CARRY:
  81                         return !this->m_C;
  82                         break;
  83                 case CARRY:
  84                         return this->m_C;
  85                         break;
  86                 case NOT_SIGNED:
  87                         return !this->m_S;
  88                         break;
  89                 case SIGNED:
  90                         return this->m_S;
  91                         break;
  92                 case ABOVE:
  93                         return (!this->m_C && !this->m_Z);
  94                         break;
  95                 case BELOW_EQ:
  96                         return (this->m_C || this->m_Z);
  97                         break;
  98                 case GREATER_EQ:
  99                         return (this->m_S == this->m_O);
 100                         break;
 101                 case LESS:
 102                         return (this->m_S != this->m_O);
 103                         break;
 104                 case GREATER:
 105                         return (!this->m_Z && (this->m_S == this->m_O));
 106                         break;
 107                 case LESS_EQ:
 108                         return (!this->m_Z || (this->m_S != this->m_O));
 109                         break;
 110                 case ALWAYS:
 111                         return true;
 112                         break;
 113                 case NEVER:
 114                         return false;
 115                         break;
 116                 default:
 117                         cerr << "What did you do? more than 16 values in 5 bits?!" << endl;
 118                         return false;
 119         }
 120
 121 }
 122
 123 CDat CCpu::getNextPC() const
 124 {
 125         return m_pc_next;
 126 }
 127
 128 CDat CCpu::getCurPC() const
 129 {
 130         return m_pc;
 131 }
 132
 133 void CCpu::setNextPC(CDat val)
 134 {
 135         m_pc_next = val;
 136 }
 137
 138 CDat CCpu::getFlags() const {
 139         CDat psw = 0;
 140         psw += (this->m_Z ? 1 : 0);
 141         psw += (this->m_O ? 2 : 0);
 142         psw += (this->m_C ? 4 : 0);
 143         psw += (this->m_S ? 8 : 0);
 144         return psw;
 145 }
 146
 147 void CCpu::setFlags(CDat psw) {
 148         this->m_Z = ((psw & 0x1) != 0);
 149         this->m_O = ((psw & 0x2) != 0);
 150         this->m_C = ((psw & 0x4) != 0);
 151         this->m_S = ((psw & 0x8) != 0);
 152 }
 153
 154 void CCpu::updateFlags(CDat val) {
 155         this->m_Z = (val == 0);
 156         this->m_S = ((val >> (BIT_LEN-1)) & 0x1);
 157 /*      this->m_C = false;
 158         this->m_O = false; */
 159 }
 160
 161 void CCpu::updateFlags(CDatd val, CDat a, CDat b) {
 162         this->m_Z = (val == 0);
 163         this->m_S = ((val >> (BIT_LEN-1)) & 0x1);
 164         this->m_C = ((val >> (BIT_LEN)) & 0x1);
 165         bool a_31 = ((a >> (BIT_LEN-1)) & 0x1);
 166         bool b_31 = ((b >> (BIT_LEN-1)) & 0x1);
 167         bool val_31 = ((val >> (BIT_LEN-1)) & 0x1);
 168         this->m_O = ((a_31 && b_31 && !val_31) || (!a_31 && !b_31 && val_31));
 169 }
 170
 171 void CCpu::updateCarry(bool c)
 172 {
 173         this->m_C = c;
 174 }
 175
 176 bool CCpu::getCarry()
 177 {
 178         return this->m_C;
 179 }
 180
 181 void CCpu::updateFlags(bool z, bool o, bool c, bool s)
 182 {
 183         this->m_Z = z;
 184         this->m_O = o;
 185         this->m_C = c;
 186         this->m_S = s;
 187 }
 188
 189 CDat CCpu::getRegister(const int addr) const
 190 {
 191         return m_reg.getDirect(addr);
 192 }
 193
 194 void CCpu::setRegister(const int addr, CDat data)
 195 {
 196         m_reg.setDirect(addr, data);
 197 }
 198
 199 CDat CCpu::getRAM(const int addr) const
 200 {
 201         if((addr & EXT_MODEL_OFFSET) == 0) {
 202                 return m_ram.get(addr);
 203         }
 204         else {
 205                 CDat result = 0;
 206                 for(auto iter = m_exts.begin(); iter != m_exts.end(); ++iter) {
 207                         result = (*iter)->readData(addr);
 208                         if(result != 0) {
 209                                 break;
 210                         }
 211                 }
 212                 return result;
 213         }
 214 }
 215
 216 void CCpu::setRAM(const int addr, CDat data)
 217 {
 218         if((addr & EXT_MODEL_OFFSET) == 0) {
 219                 m_ram.set(addr, data);
 220         }
 221         else {
 222                 for(auto iter = m_exts.begin(); iter != m_exts.end(); ++iter) {
 223                         (*iter)->loadData(addr, data);
 224                 }
 225         }
 226 }
 227
 228 void CCpu::setProg(int addr, Iinstr* instr)
 229 {
 230         m_prog.set(addr, instr);
 231 }
 232
 233 Iinstr* CCpu::getProg(const int addr) const
 234 {
 235         return m_prog.get(addr);
 236 }
 237
 238 int CCpu::getStack() const
 239 {
 240         return this->m_stack;
 241 }
 242
 243 void CCpu::setStack(const int val)
 244 {
 245         this->m_stack = val;
 246 }
 247
 248 CDat CCpu::getPerf() const
 249 {
 250         return this->m_perf;
 251 }
 252
 253 void CCpu::setPerf(CDat val)
 254 {
 255         this->m_perf = val;
 256 }
 257
 258 void CCpu::incPerf()
 259 {
 260         this->m_perf++;
 261 }
 262
 263 void CCpu::incPerfBy(short inc)
 264 {
 265         this->m_perf += inc;
 266 }
 267
 268
 269 CCpu::CCpu(int regs, int ram, int prog) : m_Z(false), m_S(false), m_C(false), m_O(false), m_pc(0), m_pc_next(0), m_perf(0), m_reg(regs), m_ram(ram), m_prog(prog), m_exts(0), m_stack(0)
 270 {
 271 }
 272
 273