Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

// SystemC GDB RSP server: implementation

// SystemC GDB RSP server: implementation

// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>

// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>

// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

// Contributor Julius Baxter <julius@orsoc.se>

// Contributor Julius Baxter <julius@orsoc.se>

// This file is part of the GDB interface to the cycle accurate model of the

// This file is part of the GDB interface to the cycle accurate model of the

// OpenRISC 1000 based system-on-chip, ORPSoC, built using Verilator.

// OpenRISC 1000 based system-on-chip, ORPSoC, built using Verilator.

// This program is free software: you can redistribute it and/or modify it

// This program is free software: you can redistribute it and/or modify it

// under the terms of the GNU Lesser General Public License as published by

// under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or (at your

// the Free Software Foundation, either version 3 of the License, or (at your

// option) any later version.

// option) any later version.

// This program is distributed in the hope that it will be useful, but WITHOUT

// This program is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

// License for more details.

// License for more details.

// You should have received a copy of the GNU Lesser General Public License

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

// $Id$

// $Id$

#include <iostream>

#include <iostream>

#include <iomanip>

#include <iomanip>

#include "GdbServerSC.h"

#include "GdbServerSC.h"

#include "Utils.h"

#include "Utils.h"

#include <errno.h>

#include <errno.h>

#include <fcntl.h>

#include <fcntl.h>

extern int monitor_to_gdb_pipe[2][2]; // [0][] - monitor to gdb, [1][] - gdb to monitor, [][0] - read, [][1] - write

extern int monitor_to_gdb_pipe[2][2];   // [0][] - monitor to gdb, [1][] - gdb to monitor, [][0] - read, [][1] - write

using std::cerr;

using std::cerr;

using std::dec;

using std::dec;

using std::endl;

using std::endl;

using std::hex;

using std::hex;

using sc_core::sc_fifo;

using sc_core::sc_fifo;

using sc_core::sc_module_name;

using sc_core::sc_module_name;

using sc_core::sc_stop;

using sc_core::sc_stop;

using sc_core::sc_time;

using sc_core::sc_time;

SC_HAS_PROCESS (GdbServerSC);

SC_HAS_PROCESS (GdbServerSC);

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Constructor for the GDB RSP server.

//! Constructor for the GDB RSP server.

//! We create a SC_THREAD which will act as the listener. Must be a

//! We create a SC_THREAD which will act as the listener. Must be a

//! thread, since we need to wait for the actions to complete.

//! thread, since we need to wait for the actions to complete.

//! The current scan chain is marked as undefined.

//! The current scan chain is marked as undefined.

//! This makes use of the Embecosm cycle accurate SystemC JTAG interface.

//! This makes use of the Embecosm cycle accurate SystemC JTAG interface.

//! @see Embecosm Application Note 5 "Using JTAG with SystemC: Implementation

//! @see Embecosm Application Note 5 "Using JTAG with SystemC: Implementation

//!      of a Cycle Accurate Interface"

//!      of a Cycle Accurate Interface"

//!      (http://www.embecosm.com/download/ean5.html)

//!      (http://www.embecosm.com/download/ean5.html)

//! @todo We do not handle a user coded l.trap properly (i.e. one that is not

//! @todo We do not handle a user coded l.trap properly (i.e. one that is not

//!       a breakpoint). Effectively it is ignored, whereas we ought to set up

//!       a breakpoint). Effectively it is ignored, whereas we ought to set up

//!       the exception registers and redirect through the trap vector.

//!       the exception registers and redirect through the trap vector.

//! @param[in] name             Name of this module, passed to the parent

//! @param[in] name             Name of this module, passed to the parent

//!                             constructor. 

//!                             constructor. 

//! @param[in] _tapActionQueue  Pointer to fifo of actions to be performed by

//! @param[in] _tapActionQueue  Pointer to fifo of actions to be performed by

//!                             the JTAG interface

//!                             the JTAG interface

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

GdbServerSC::GdbServerSC (sc_module_name        name,

GdbServerSC::GdbServerSC(sc_module_name name,

                          uint32_t              _flashStart,

                         uint32_t _flashStart,

                          uint32_t              _flashEnd,

                         uint32_t _flashEnd,

                          int                   rspPort,

                          int                   rspPort,

{

{

  pkt       = new RspPacket (RSP_PKT_MAX);

        pkt = new RspPacket(RSP_PKT_MAX);

  rsp       = new RspConnection (rspPort);

        rsp = new RspConnection(rspPort);

  debugUnit = new DebugUnitSC ("debug-unit", tapActionQueue);

        debugUnit = new DebugUnitSC("debug-unit", tapActionQueue);

  mpHash    = new MpHash ();

        mpHash = new MpHash();

  /* Setup the pipes between or1200 monitor module and GDB stub */

        /* Setup the pipes between or1200 monitor module and GDB stub */

  pipe(monitor_to_gdb_pipe[0]);

        pipe(monitor_to_gdb_pipe[0]);

  pipe(monitor_to_gdb_pipe[1]);

        pipe(monitor_to_gdb_pipe[1]);

  // Set non-blocking reads

        // Set non-blocking reads

#ifdef O_NONBLOCK /* The POSIX way */

#ifdef O_NONBLOCK               /* The POSIX way */

  fcntl (monitor_to_gdb_pipe[0][0], F_SETFL, O_NONBLOCK);

        fcntl(monitor_to_gdb_pipe[0][0], F_SETFL, O_NONBLOCK);

  fcntl (monitor_to_gdb_pipe[1][0], F_SETFL, O_NONBLOCK);

        fcntl(monitor_to_gdb_pipe[1][0], F_SETFL, O_NONBLOCK);

#elif defined (O_NDELAY)

#elif defined (O_NDELAY)

  fcntl (monitor_to_gdb_pipe[0][0], F_SETFL, O_NDELAY);

        fcntl(monitor_to_gdb_pipe[0][0], F_SETFL, O_NDELAY);

  fcntl (monitor_to_gdb_pipe[1][0], F_SETFL, O_NDELAY);

        fcntl(monitor_to_gdb_pipe[1][0], F_SETFL, O_NDELAY);

#endif /* O_NONBLOCK */

#endif /* O_NONBLOCK */

  SC_THREAD (rspServer);

        SC_THREAD(rspServer);

}       // GdbServerSC ()

}                               // GdbServerSC ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Destructor

//! Destructor

//! Free up data structures

//! Free up data structures

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

GdbServerSC::~GdbServerSC ()

GdbServerSC::~GdbServerSC()

{

{

  delete  mpHash;

        delete mpHash;

  delete  debugUnit;

        delete debugUnit;

  delete  rsp;

        delete rsp;

  delete  pkt;

        delete pkt;

}       // ~GdbServerSC

}                               // ~GdbServerSC

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! SystemC thread to listen for RSP requests

//! SystemC thread to listen for RSP requests

//! JTAG actions will be queued as appropriate. Runs forever

//! JTAG actions will be queued as appropriate. Runs forever

//! We don't allow any actions until the target is out of its startup mode

//! We don't allow any actions until the target is out of its startup mode

//! (where the ROM is mapped into RAM space). This is determined by seeing if

//! (where the ROM is mapped into RAM space). This is determined by seeing if

//! the PPC is still in flash memory.

//! the PPC is still in flash memory.

//! Have to use a thread, since we will end up waiting for actions to

//! Have to use a thread, since we will end up waiting for actions to

//! complete.

//! complete.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

void

void

GdbServerSC::rspServer ()

 GdbServerSC::rspServer()

{

{

  // Reset the debug unit, and wait for ORPSoC to be ready, by noting when it

        // Reset the debug unit, and wait for ORPSoC to be ready, by noting when it

  // accesses an address outside of flash. Note that we use NPC, not PPC since

        // accesses an address outside of flash. Note that we use NPC, not PPC since

  // at reset PPC is zero, and would trigger a false positive.

        // at reset PPC is zero, and would trigger a false positive.

  debugUnit->resetDebugUnit ();

        debugUnit->resetDebugUnit();

  rsp_sigval = TARGET_SIGNAL_NONE;

        rsp_sigval = TARGET_SIGNAL_NONE;

  /*

        /*

  uint32_t npc;

           uint32_t npc;

  do

           do

    {

           {

      npc = debugUnit->readSpr (SPR_NPC);

           npc = debugUnit->readSpr (SPR_NPC);

    }

           }

  while ((flashStart <= npc) && (npc <= flashEnd));

           while ((flashStart <= npc) && (npc <= flashEnd));

  */

         */

  debugUnit->stall ();

        debugUnit->stall();

  targetStopped = true;

        targetStopped = true;

  // Make sure we are connected.

  // Make sure we are connected.

      // Reconnect and stall the processor on a new connection

      // Reconnect and stall the processor on a new connection

          // Serious failure. Must abort execution.

          // Serious failure. Must abort execution.

          cerr << "*** Unable to continue: ABORTING" << endl;

                        cerr << "*** Unable to continue: ABORTING" << endl;

          sc_stop ();

                        sc_stop();

        }

        }

      // Stall the processor until we get a command to handle.

      // Stall the processor until we get a command to handle.

          debugUnit->stall ();

          debugUnit->stall ();

        }

                }

      targetStopped = true;             // Processor now not running

                targetStopped = true;   // Processor now not running

    }

        }

  // Loop processing commands forever

  // Loop processing commands forever

          sc_stop ();

          sc_stop ();

          return;

                        return;

        }

                }

      // Wait until the target has stopped. In this simplified implementation,

                // Wait until the target has stopped. In this simplified implementation,

      // the only reasons for stopping are hitting a breakpoint (l.trap),

                // the only reasons for stopping are hitting a breakpoint (l.trap),

      // hardware single stepping or hitting a non-breakpoint l.trap. This

                // hardware single stepping or hitting a non-breakpoint l.trap. This

      // last is not cleanly handled at the moment (we ought to redirect the

                // last is not cleanly handled at the moment (we ought to redirect the

      // restart through the trap exception vector).

      // restart through the trap exception vector).

          /* First check to see if the or1200 monitor module wants us to stall*/

                        /* First check to see if the or1200 monitor module wants us to stall */

          if (checkMonitorPipe())

                        if (checkMonitorPipe())

            break;

                                break;

          rspCheckForException();

                        rspCheckForException();

              targetStopped = true;

              targetStopped = true;

              // If it's a breakpoint, then we need to back up one

                                // If it's a breakpoint, then we need to back up one

              // instruction, so on restart we execute the actual

                                // instruction, so on restart we execute the actual

              // instruction.

                                // instruction.

              uint32_t  ppc = debugUnit->readSpr (SPR_PPC);

                                uint32_t ppc = debugUnit->readSpr(SPR_PPC);

                  writeNpc (ppc);

                  writeNpc (ppc);

                }

                }

              // Tell the client we've stopped.

              // Tell the client we've stopped.

              rspReportException ();

              rspReportException ();

              if (rsp->rspSocketPeek() == 0x03) // ETX, end of text control char

              if (rsp->rspSocketPeek() == 0x03) // ETX, end of text control char

                {

                                {

                  // Got an interrupt command from GDB, this function should

                                        // Got an interrupt command from GDB, this function should

                  // pull the packet off the socket and stall the processor.

                                        // pull the packet off the socket and stall the processor.

                  // and then send a stop reply packet with signal 

                                        // and then send a stop reply packet with signal 

                  // TARGET_SIGNAL_NONE.

                                        // TARGET_SIGNAL_NONE.

                  rspInterrupt();

                                        rspInterrupt();

                  targetStopped = true;         // Processor now not running

                                        targetStopped = true;   // Processor now not running

                }

                                }

            }

                        }

        }

                }

      // Get a RSP client request

                // Get a RSP client request

      rspClientRequest ();

                rspClientRequest();

    }

        }

}       // rspServer ()

}                               // rspServer ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Deal with a request from the GDB client session

//! Deal with a request from the GDB client session

//! In general, apart from the simplest requests, this function replies on

//! In general, apart from the simplest requests, this function replies on

//! other functions to implement the functionality.

//! other functions to implement the functionality.

//! @note It is the responsibility of the recipient to delete the packet when

//! @note It is the responsibility of the recipient to delete the packet when

//!       it is finished with. It is permissible to reuse the packet for a

//!       it is finished with. It is permissible to reuse the packet for a

//!       reply.

//!       reply.

//! @todo Is this the implementation of the 'D' packet really the intended

//! @todo Is this the implementation of the 'D' packet really the intended

//!       meaning? Or does it just mean that only vAttach will be recognized

//!       meaning? Or does it just mean that only vAttach will be recognized

//!       after this?

//!       after this?

//! @param[in] pkt  The received RSP packet

//! @param[in] pkt  The received RSP packet

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

    {

    {

      rsp->rspClose ();                 // Comms failure

      rsp->rspClose ();                 // Comms failure

      return;

                return;

    }

        }

  //Uncomment the next line for the RSP client to print out every packet it gets from GDB

        //Uncomment the next line for the RSP client to print out every packet it gets from GDB

  //cerr << "rspClientRequest: " << pkt->data/*[0]*/ << endl;

  //cerr << "rspClientRequest: " << pkt->data/*[0]*/ << endl;

    case '!':

    case '!':

      // Request for extended remote mode

                // Request for extended remote mode

      pkt->packStr ("OK");

                pkt->packStr("OK");

      rsp->putPkt (pkt);

                rsp->putPkt(pkt);

      return;

                return;

    case '?':

        case '?':

      // Return last signal ID

                // Return last signal ID

      rspReportException ();

                rspReportException();

      return;

                return;

    case 'A':

        case 'A':

      // Initialization of argv not supported

      // Initialization of argv not supported

      pkt->packStr ("E01");

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

                rsp->putPkt(pkt);

      return;

                return;

    case 'b':

        case 'b':

      // Setting baud rate is deprecated

                // Setting baud rate is deprecated

      cerr << "Warning: RSP 'b' packet is deprecated and not "

                cerr << "Warning: RSP 'b' packet is deprecated and not "

           << "supported: ignored" << endl;

                    << "supported: ignored" << endl;

      return;

                return;

    case 'B':

        case 'B':

      // Breakpoints should be set using Z packets

                // Breakpoints should be set using Z packets

      cerr << "Warning: RSP 'B' packet is deprecated (use 'Z'/'z' "

                cerr << "Warning: RSP 'B' packet is deprecated (use 'Z'/'z' "

           << "packets instead): ignored" << endl;

                    << "packets instead): ignored" << endl;

      return;

                return;

    case 'c':

        case 'c':

      // Continue

                // Continue

      rspContinue (EXCEPT_NONE);

                rspContinue(EXCEPT_NONE);

      return;

                return;

    case 'C':

        case 'C':

      // Continue with signal (in the packet)

                // Continue with signal (in the packet)

      rspContinue ();

                rspContinue();

      return;

                return;

    case 'd':

        case 'd':

      // Disable debug using a general query

                // Disable debug using a general query

      cerr << "Warning: RSP 'd' packet is deprecated (define a 'Q' "

                cerr << "Warning: RSP 'd' packet is deprecated (define a 'Q' "

           << "packet instead: ignored" << endl;

                    << "packet instead: ignored" << endl;

      return;

                return;

    case 'D':

        case 'D':

      // Detach GDB. Do this by closing the client. The rules say that

                // Detach GDB. Do this by closing the client. The rules say that

      // execution should continue, so unstall the processor.

                // execution should continue, so unstall the processor.

      pkt->packStr("OK");

                pkt->packStr("OK");

      rsp->putPkt (pkt);

                rsp->putPkt(pkt);

      rsp->rspClose ();

                rsp->rspClose();

      //debugUnit->unstall ();      

                //debugUnit->unstall ();      

      return;

                return;

    case 'F':

        case 'F':

      // File I/O is not currently supported

                // File I/O is not currently supported

      cerr << "Warning: RSP file I/O not currently supported: 'F' "

                cerr << "Warning: RSP file I/O not currently supported: 'F' "

           << "packet ignored" << endl;

                    << "packet ignored" << endl;

      return;

                return;

    case 'g':

        case 'g':

      rspReadAllRegs ();

                rspReadAllRegs();

      return;

                return;

    case 'G':

        case 'G':

      rspWriteAllRegs ();

                rspWriteAllRegs();

      return;

                return;

    case 'H':

        case 'H':

      // Set the thread number of subsequent operations. For now ignore

                // Set the thread number of subsequent operations. For now ignore

      // silently and just reply "OK"

                // silently and just reply "OK"

      pkt->packStr ("OK");

                pkt->packStr("OK");

      rsp->putPkt (pkt);

                rsp->putPkt(pkt);

      return;

                return;

    case 'i':

        case 'i':

    case 'I':

        case 'I':

      // Single cycle step not currently supported. Mark the target as

                // Single cycle step not currently supported. Mark the target as

      // running, so that next time it will be detected as stopped (it is

                // running, so that next time it will be detected as stopped (it is

      // still stalled in reality) and an ack sent back to the client.

                // still stalled in reality) and an ack sent back to the client.

      cerr << "Warning: RSP cycle stepping not supported: target "

                cerr << "Warning: RSP cycle stepping not supported: target "

           << "stopped immediately" << endl;

                    << "stopped immediately" << endl;

      targetStopped = false;

                targetStopped = false;

      return;

                return;

    case 'k':

        case 'k':

      // Kill request. Do nothing for now.

                // Kill request. Do nothing for now.

      return;

                return;

    case 'm':

        case 'm':

      // Read memory (symbolic)

                // Read memory (symbolic)

      rspReadMem ();

                rspReadMem();

      return;

                return;

    case 'M':

        case 'M':

      // Write memory (symbolic)

                // Write memory (symbolic)

      rspWriteMem ();

                rspWriteMem();

      return;

                return;

    case 'p':

        case 'p':

      // Read a register

                // Read a register

      rspReadReg ();

                rspReadReg();

      return;

                return;

    case 'P':

        case 'P':

      // Write a register

                // Write a register

      rspWriteReg ();

                rspWriteReg();

      return;

                return;

    case 'q':

        case 'q':

      // Any one of a number of query packets

                // Any one of a number of query packets

      rspQuery ();

                rspQuery();

      return;

                return;

    case 'Q':

        case 'Q':

      // Any one of a number of set packets

                // Any one of a number of set packets

      rspSet ();

                rspSet();

      return;

                return;

    case 'r':

        case 'r':

      // Reset the system. Deprecated (use 'R' instead)

                // Reset the system. Deprecated (use 'R' instead)

      cerr << "Warning: RSP 'r' packet is deprecated (use 'R' "

                cerr << "Warning: RSP 'r' packet is deprecated (use 'R' "

                << "packet instead): ignored" << endl;

                    << "packet instead): ignored" << endl;

      return;

                return;

    case 'R':

        case 'R':

      // Restart the program being debugged.

                // Restart the program being debugged.

      rspRestart ();

                rspRestart();

      return;

                return;

    case 's':

        case 's':

      // Single step one machine instruction.

                // Single step one machine instruction.

      rspStep (EXCEPT_NONE);

                rspStep(EXCEPT_NONE);

      return;

                return;

    case 'S':

        case 'S':

      // Single step one machine instruction.

                // Single step one machine instruction.

      rspStep ();

                rspStep();

      return;

                return;

    case 't':

        case 't':

      // Search. This is not well defined in the manual and for now we don't

                // Search. This is not well defined in the manual and for now we don't

      // support it. No response is defined.

                // support it. No response is defined.

      cerr << "Warning: RSP 't' packet not supported: ignored"

                cerr << "Warning: RSP 't' packet not supported: ignored"

                << endl;

                    << endl;

      return;

                return;

    case 'T':

        case 'T':

      // Is the thread alive. We are bare metal, so don't have a thread

                // Is the thread alive. We are bare metal, so don't have a thread

      // context. The answer is always "OK".

                // context. The answer is always "OK".

      pkt->packStr ("OK");

                pkt->packStr("OK");

      rsp->putPkt (pkt);

                rsp->putPkt(pkt);

      return;

                return;

    case 'v':

        case 'v':

      // Any one of a number of packets to control execution

                // Any one of a number of packets to control execution

      rspVpkt ();

                rspVpkt();

      return;

                return;

    case 'X':

        case 'X':

      // Write memory (binary)

                // Write memory (binary)

      rspWriteMemBin ();

                rspWriteMemBin();

      return;

                return;

    case 'z':

        case 'z':

      // Remove a breakpoint/watchpoint.

                // Remove a breakpoint/watchpoint.

      rspRemoveMatchpoint ();

                rspRemoveMatchpoint();

      return;

                return;

    case 'Z':

        case 'Z':

      // Insert a breakpoint/watchpoint.

                // Insert a breakpoint/watchpoint.

      rspInsertMatchpoint ();

                rspInsertMatchpoint();

      return;

                return;

    default:

        default:

      // Unknown commands are ignored

                // Unknown commands are ignored

      cerr << "Warning: Unknown RSP request" << pkt->data << endl;

                cerr << "Warning: Unknown RSP request" << pkt->data << endl;

      return;

                return;

    }

        }

}       // rspClientRequest ()

}                               // rspClientRequest ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Check if processor is stalled. If it is, read the DRR and return the

//! Check if processor is stalled. If it is, read the DRR and return the

//! target signal code.

//! target signal code.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  uint32_t drr;

        uint32_t drr;

      // Processor not stalled. Just return;

      // Processor not stalled. Just return;

      return;

                return;

    }

        }

    default:

        default:

      // This must be the case of single step (which does not set DRR)

      // This must be the case of single step (which does not set DRR)

    }

    }

  return;

        return;

}

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Send a packet acknowledging an exception has occurred

//! Send a packet acknowledging an exception has occurred

//! The only signal we ever see in this implementation is TRAP.

//! The only signal we ever see in this implementation is TRAP.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // Construct a signal received packet

        // Construct a signal received packet

  pkt->data[0] = 'S';

        pkt->data[0] = 'S';

  pkt->data[1] = Utils::hex2Char (rsp_sigval >> 4);

        pkt->data[1] = Utils::hex2Char(rsp_sigval >> 4);

  pkt->data[2] = Utils::hex2Char (rsp_sigval % 16);

        pkt->data[2] = Utils::hex2Char(rsp_sigval % 16);

  pkt->data[3] = '\0';

        pkt->data[3] = '\0';

  pkt->setLen (strlen (pkt->data));

        pkt->setLen(strlen(pkt->data));

  rsp->putPkt (pkt);

        rsp->putPkt(pkt);

}       // rspReportException ()

}                               // rspReportException ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP continue request

//! Handle a RSP continue request

//! This version is typically used for the 'c' packet, to continue without

//! This version is typically used for the 'c' packet, to continue without

//! signal, in which case EXCEPT_NONE is passed in as the exception to use.

//! signal, in which case EXCEPT_NONE is passed in as the exception to use.

//! At present other exceptions are not supported

//! At present other exceptions are not supported

//! @param[in] except  The OpenRISC 1000 exception to use

//! @param[in] except  The OpenRISC 1000 exception to use

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  uint32_t  addr;                       // Address to continue from, if any

        uint32_t addr;          // Address to continue from, if any

  // Reject all except 'c' packets

  // Reject all except 'c' packets

      return;

      return;

    }

    }

  // Get an address if we have one

  // Get an address if we have one

      addr = readNpc ();                // Default uses current NPC

      addr = readNpc ();                // Default uses current NPC

      cerr << "Warning: RSP continue address " << pkt->data

      cerr << "Warning: RSP continue address " << pkt->data

                << " not recognized: ignored" << endl;

                    << " not recognized: ignored" << endl;

      addr = readNpc ();                // Default uses current NPC

                addr = readNpc();       // Default uses current NPC

    }

        }

  rspContinue (addr, EXCEPT_NONE);

        rspContinue(addr, EXCEPT_NONE);

}       // rspContinue ()

}                               // rspContinue ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP continue with signal request

//! Handle a RSP continue with signal request

//! @todo Currently does nothing. Will use the underlying generic continue

//! @todo Currently does nothing. Will use the underlying generic continue

//!       function. 

//!       function. 

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  cerr << "RSP continue with signal '" << pkt->data

        cerr << "RSP continue with signal '" << pkt->data

       << "' received" << endl;

            << "' received" << endl;

}       // rspContinue ()

}                               // rspContinue ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Generic processing of a continue request

//! Generic processing of a continue request

//! The signal may be EXCEPT_NONE if there is no exception to be

//! The signal may be EXCEPT_NONE if there is no exception to be

//! handled. Currently the exception is ignored.

//! handled. Currently the exception is ignored.

//! The single step flag is cleared in the debug registers and then the

//! The single step flag is cleared in the debug registers and then the

//! processor is unstalled.

//! processor is unstalled.

//! @param[in] addr    Address from which to step

//! @param[in] addr    Address from which to step

//! @param[in] except  The exception to use (if any)                         

//! @param[in] except  The exception to use (if any)                         

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // Set the address as the value of the next program counter

        // Set the address as the value of the next program counter

  writeNpc (addr);

        writeNpc(addr);

  /*

        /*

  // If we're continuing from a breakpoint, replace that instruction in the memory

           // If we're continuing from a breakpoint, replace that instruction in the memory