3c_disasm/instr/stackop.cpp

   1 /*   `Deep Thought', a softcore CPU implemented on a FPGA
   2
   3     Copyright (C) 2010 Markus Hofstaetter <markus.manrow@gmx.at>
   4     Copyright (C) 2010 Martin Perner <e0725782@student.tuwien.ac.at>
   5     Copyright (C) 2010 Stefan Rebernig <stefan.rebernig@gmail.com>
   6     Copyright (C) 2010 Manfred Schwarz <e0725898@student.tuwien.ac.at>
   7     Copyright (C) 2010 Bernhard Urban <lewurm@gmail.com>
   8
   9     This program is free software: you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation, either version 3 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  21
  22 #include "../Iinstr.hpp"
  23
  24 class Cstackop : public Iinstr {
  25                 char m_typ;
  26         public:
  27                 Cstackop();
  28                 void evalInstr();
  29                 void execInstr();
  30                 std::string toString();
  31                 Iinstr* getNew();
  32 };
  33
  34 /**
  35  * Name:      create_instruction
  36  * Purpose:   if compiled as shared library, this functions creates the
  37               instruction object
  38
  39  * Returns:   pointer to instruction object
  40  */
  41 extern "C" Iinstr* create_instruction() {
  42     return new Cstackop();
  43 }
  44
  45 Iinstr* Cstackop::getNew()
  46 {
  47         return new Cstackop();
  48 }
  49 /**
  50  * Name:      destroy_instruction
  51  * Purpose:   if compiled as shared library, this functions destoys the
  52               instruction object
  53
  54  * Parameter: IInstruction - the instruction object to delete
  55  */
  56 extern "C" void destroy_instruction(Iinstr* p) {
  57     delete p;
  58 }
  59
  60 Cstackop::Cstackop() : m_typ(0)
  61 {
  62         opcode = B5(01011);
  63         name = "stackop";
  64 }
  65
  66 void Cstackop::evalInstr()
  67 {
  68         argbits >>= 17;
  69
  70         dynamic_bitset<> type = argbits;
  71         type.resize(2);
  72         this->m_typ = type.to_ulong();
  73
  74         switch(this->m_typ) {
  75                 case 0:
  76                         this->name = "pop";
  77                         break;
  78                 case 1:
  79                         this->name = "disc";
  80                         break;
  81                 case 2:
  82                         this->name = "fetch";
  83                         break;
  84                 case 3:
  85                         this->name = "push";
  86                         break;
  87                 default:
  88                         cerr << "What have you done? 2 bits that have more than 4 values?!" << endl;
  89         }
  90
  91         argbits >>= 2;
  92         m_rd = this->getRegister(argbits);
  93 }
  94
  95 void Cstackop::execInstr()
  96 {
  97         CDat sp = this->m_cpu->getStack();
  98
  99         switch(this->m_typ) {
 100                 case 0:
 101                         this->m_cpu->setRegister(m_rd, this->m_cpu->getRAM(sp));
 102                         sp += 4;
 103                         break;
 104                 case 1:
 105                         sp += 4;
 106                         break;
 107                 case 2:
 108                         this->m_cpu->setRegister(m_rd, this->m_cpu->getRAM(sp));
 109                         break;
 110                 case 3:
 111                         sp -= 4;
 112                         this->m_cpu->setRAM(sp, this->m_cpu->getRegister(m_rd));
 113                         break;
 114                 default:
 115                         cerr << "What have you done? 2 bits that have more than 4 values?!" << endl;
 116         }
 117
 118         this->m_cpu->setStack(sp);
 119 }
 120
 121 std::string Cstackop::toString()
 122 {
 123         stringstream op;
 124         op << this->getName();
 125
 126         op << this->getConditionFlag();
 127         op << " r" << m_rd;
 128         return op.str();
 129 }