DebugInterface.cpp

   1 #include "DebugInterface.h"
   2 #include "Core.h"
   3 #include "Trace.h"
   4 #include "Device.h"
   5 #include "Instruction.h"
   6 #include "AccessViolation.h"
   7 #include "ImplementationException.h"
   8
   9 #include <algorithm>
  10
  11 namespace avr {
  12         DebugInterface::DebugInterface(Device & dev, Core & core)
  13                 : dev(dev), core(core), breaked(false) {
  14                 core.setDebugInterface(this);
  15         }
  16
  17         DebugInterface::~DebugInterface() {
  18                 core.setDebugInterface(0);
  19         }
  20
  21         byte DebugInterface::reg(int reg) const {
  22                 return core.readRegister(reg);
  23         }
  24
  25         byte DebugInterface::status() const {
  26                 return core.readStatus();
  27         }
  28
  29         word DebugInterface::stackPointer() const {
  30                 return core.stack.getSP();
  31         }
  32
  33         dword DebugInterface::programCounter() const {
  34                 return (core.PC << 1);
  35         }
  36
  37         const unsigned char *DebugInterface::readRam(
  38                         unsigned int offset, unsigned int size) const {
  39
  40                 if( offset < core.registerSpaceSize + core.regs.size() )
  41                         throw AccessViolation("readRam: Tried to read to register area");
  42
  43                 offset -= core.registerSpaceSize + core.regs.size();
  44                 return core.sram.read(offset, size);
  45         }
  46
  47         const unsigned char *DebugInterface::readFlash(
  48                         unsigned int offset, unsigned int size) const {
  49
  50                 return core.flash.read( offset, size );
  51         }
  52
  53         void DebugInterface::writeRam(unsigned char *data,
  54                         unsigned int offset, unsigned int size) {
  55
  56                 if( offset < core.registerSpaceSize + core.regs.size() )
  57                         throw AccessViolation("writeRam: Tried to write to register area");
  58
  59                 offset -= core.registerSpaceSize + core.regs.size();
  60                 core.sram.write(offset, data, size);
  61         }
  62
  63         void DebugInterface::writeFlash(unsigned char *data,
  64                         unsigned int offset, unsigned int size) {
  65                 core.loadFlash(data, offset, size);
  66         }
  67
  68         const unsigned char *DebugInterface::readEeprom(
  69                         unsigned int offset, unsigned int size) const {
  70                 throw util::ImplementationException( "readEeprom: not yet implemented" );
  71         }
  72
  73         void DebugInterface::writeEeprom(unsigned char *data,
  74                         unsigned int offset, unsigned int size) {
  75                 throw util::ImplementationException( "writeEeprom: not yet implemented" );
  76         }
  77
  78         void DebugInterface::setReg(int reg, byte val) {
  79                 core.writeRegister(reg, val);
  80         }
  81
  82         void DebugInterface::setStatus(byte val) {
  83                 core.writeStatus( val );
  84         }
  85
  86         void DebugInterface::setStackPointer(word val) {
  87                 core.stack.setSP(val);
  88         }
  89
  90         void DebugInterface::setProgramCounter(dword val) {
  91                 core.PC = val >> 1;
  92         }
  93
  94         void DebugInterface::insertBreak(dword addr) {
  95                 breakPoints.push_back( addr );
  96         }
  97
  98         void DebugInterface::removeBreak(dword addr) {
  99                 std::remove(breakPoints.begin(), breakPoints.end(), addr);
 100         }
 101
 102         void DebugInterface::deleteAllBreakpoints() {
 103                 breakPoints.erase(breakPoints.begin(), breakPoints.end());
 104         }
 105
 106         bool DebugInterface::checkBreak(dword addr) {
 107                 if( breakPoints.end() != std::find(breakPoints.begin(), breakPoints.end(), addr)) {
 108                         if( ! breaked ) {
 109                                 Trace::instance().breakpoint(addr);
 110                                 breaked = true;
 111                         } else {
 112                                 breaked = false;
 113                         }
 114                 } else {
 115                         breaked = false;
 116                 }
 117
 118                 return breaked;
 119         }
 120
 121         bool DebugInterface::stepDone() const {
 122                 return (core.cpuCycles == 0);
 123         }
 124
 125         const std::string & DebugInterface::registerName(byte addr) const {
 126                 if( addr < core.registerSpaceSize )
 127                         return core.getR(addr).getName();
 128                 else
 129                         return core.getIoreg(addr - core.registerSpaceSize).getName();
 130         }
 131
 132         void DebugInterface::trace(std::ostream & ostr, dword addr) {
 133                 word opcode = core.flash.readWord( addr );
 134                 Instruction & instr = core.decoder.decode(opcode);
 135                 instr.trace(&core, ostr);
 136         }
 137
 138 }