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