Subversion Repositories openrisc_me

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

// SystemC GDB RSP server: implementation

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

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

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

// 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.

// 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

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

// option) any later version.

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

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

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

// License for more details.

// 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/>.

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

// $Id$

#include <iostream>

#include <iomanip>

#include "GdbServerSC.h"

#include "Utils.h"

#include <errno.h>

#include <fcntl.h>

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::dec;

using std::endl;

using std::hex;

using sc_core::sc_fifo;

using sc_core::sc_module_name;

using sc_core::sc_stop;

using sc_core::sc_time;

SC_HAS_PROCESS (GdbServerSC);

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

//! Constructor for the GDB RSP server.

//! 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.

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

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

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

//!      of a Cycle Accurate Interface"

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

//! @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

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

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

//!                             constructor. 

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

//!                             the JTAG interface

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

GdbServerSC::GdbServerSC (sc_module_name        name,

                          uint32_t              _flashStart,

                          uint32_t              _flashEnd,

                          int                   rspPort,

                          sc_fifo<TapAction *> *tapActionQueue) :

  sc_module (name),

  flashStart (_flashStart),

  flashEnd (_flashEnd)

{

  pkt       = new RspPacket (RSP_PKT_MAX);

  rsp       = new RspConnection (rspPort);

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

  mpHash    = new MpHash ();

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

  pipe(monitor_to_gdb_pipe[0]);

  pipe(monitor_to_gdb_pipe[1]);

  // Set non-blocking reads

#ifdef O_NONBLOCK /* The POSIX way */

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

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

#elif defined (O_NDELAY)

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

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

#endif /* O_NONBLOCK */

  SC_THREAD (rspServer);

}       // GdbServerSC ()

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

//! Destructor

//! Free up data structures

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

GdbServerSC::~GdbServerSC ()

{

  delete  mpHash;

  delete  debugUnit;

  delete  rsp;

  delete  pkt;

}       // ~GdbServerSC

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

//! SystemC thread to listen for RSP requests

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

//! 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

//! the PPC is still in flash memory.

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

//! complete.

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

void

GdbServerSC::rspServer ()

{

  // 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

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

  debugUnit->resetDebugUnit ();

  rsp_sigval = TARGET_SIGNAL_NONE;

  /*

  uint32_t npc;

  do

    {

      npc = debugUnit->readSpr (SPR_NPC);

    }

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

  */

  debugUnit->stall ();

  targetStopped = true;

  // Make sure we are connected.

  while (!rsp->isConnected ())

    {

      // Reconnect and stall the processor on a new connection

      if (!rsp->rspConnect ())

        {

          // Serious failure. Must abort execution.

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

          sc_stop ();

        }

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

      if (!debugUnit->isStalled ())

        {

          debugUnit->stall ();

        }

      targetStopped = true;             // Processor now not running

    }

  // Loop processing commands forever

  while (true)

    {

      if (!rsp->isConnected())

        {

          sc_stop ();

          return;

        }

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

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

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

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

      // restart through the trap exception vector).

      while (!targetStopped)

        {

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

          if (checkMonitorPipe())

            break;

          rspCheckForException();

          if (debugUnit->isStalled())

            {

              targetStopped = true;

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

              // instruction, so on restart we execute the actual

              // instruction.

              uint32_t  ppc = debugUnit->readSpr (SPR_PPC);

              if (NULL != mpHash->lookup (BP_MEMORY, ppc) && rsp_sigval == TARGET_SIGNAL_TRAP)

                {

                  writeNpc (ppc);

                }

              // Tell the client we've stopped.

              rspReportException ();

            }

          else if (rsp->rspSocketPeek() > 0)

            {

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

                {

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

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

                  // and then send a stop reply packet with signal 

                  // TARGET_SIGNAL_NONE.

                  rspInterrupt();

                  targetStopped = true;         // Processor now not running

                }

            }

        }

      // Get a RSP client request

      rspClientRequest ();

    }

}       // rspServer ()

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

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

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

//! other functions to implement the functionality.

//! @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

//!       reply.

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

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

//!       after this?

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

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

void

GdbServerSC::rspClientRequest ()

{

  if (!rsp->getPkt (pkt))

    {

      rsp->rspClose ();                 // Comms failure

      return;

    }

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

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

  switch (pkt->data[0])

    {

    case '!':

      // Request for extended remote mode

      pkt->packStr ("OK");

      rsp->putPkt (pkt);

      return;

    case '?':

      // Return last signal ID

      rspReportException ();

      return;

    case 'A':

      // Initialization of argv not supported

      cerr << "Warning: RSP 'A' packet not supported: ignored" << endl;

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

      return;

    case 'b':

      // Setting baud rate is deprecated

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

           << "supported: ignored" << endl;

      return;

    case 'B':

      // Breakpoints should be set using Z packets

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

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

      return;

    case 'c':

      // Continue

      rspContinue (EXCEPT_NONE);

      return;

    case 'C':

      // Continue with signal (in the packet)

      rspContinue ();

      return;

    case 'd':

      // Disable debug using a general query

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

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

      return;

    case 'D':

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

      // execution should continue, so unstall the processor.

      pkt->packStr("OK");

      rsp->putPkt (pkt);

      rsp->rspClose ();

      //debugUnit->unstall ();      

      return;

    case 'F':

      // File I/O is not currently supported

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

           << "packet ignored" << endl;

      return;

    case 'g':

      rspReadAllRegs ();

      return;

    case 'G':

      rspWriteAllRegs ();

      return;

    case 'H':

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

      // silently and just reply "OK"

      pkt->packStr ("OK");

      rsp->putPkt (pkt);

      return;

    case 'i':

    case 'I':

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

      // 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.

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

           << "stopped immediately" << endl;

      targetStopped = false;

      return;

    case 'k':

      // Kill request. Do nothing for now.

      return;

    case 'm':

      // Read memory (symbolic)

      rspReadMem ();

      return;

    case 'M':

      // Write memory (symbolic)

      rspWriteMem ();

      return;

    case 'p':

      // Read a register

      rspReadReg ();

      return;

    case 'P':

      // Write a register

      rspWriteReg ();

      return;

    case 'q':

      // Any one of a number of query packets

      rspQuery ();

      return;

    case 'Q':

      // Any one of a number of set packets

      rspSet ();

      return;

    case 'r':

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

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

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

      return;

    case 'R':

      // Restart the program being debugged.

      rspRestart ();

      return;

    case 's':

      // Single step one machine instruction.

      rspStep (EXCEPT_NONE);

      return;

    case 'S':

      // Single step one machine instruction.

      rspStep ();

      return;

    case 't':

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

      // support it. No response is defined.

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

                << endl;

      return;

    case 'T':

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

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

      pkt->packStr ("OK");

      rsp->putPkt (pkt);

      return;

    case 'v':

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

      rspVpkt ();

      return;

    case 'X':

      // Write memory (binary)

      rspWriteMemBin ();

      return;

    case 'z':

      // Remove a breakpoint/watchpoint.

      rspRemoveMatchpoint ();

      return;

    case 'Z':

      // Insert a breakpoint/watchpoint.

      rspInsertMatchpoint ();

      return;

    default:

      // Unknown commands are ignored

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

      return;

    }

}       // rspClientRequest ()

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

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

//! target signal code.

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

void

GdbServerSC::rspCheckForException()

{

  uint32_t drr;

  if (!debugUnit->isStalled())

    {

      // Processor not stalled. Just return;

      return;

    }

  switch ((debugUnit->readSpr(SPR_DRR)&0xffffffff))

    {

    case SPR_DRR_RSTE:  rsp_sigval = TARGET_SIGNAL_PWR;  break;

    case SPR_DRR_BUSEE: rsp_sigval = TARGET_SIGNAL_BUS;  break;

    case SPR_DRR_DPFE:  rsp_sigval = TARGET_SIGNAL_SEGV; break;

    case SPR_DRR_IPFE:  rsp_sigval = TARGET_SIGNAL_SEGV; break;

    case SPR_DRR_TTE:   rsp_sigval = TARGET_SIGNAL_ALRM; break;

    case SPR_DRR_AE:    rsp_sigval = TARGET_SIGNAL_BUS;  break;

    case SPR_DRR_IIE:   rsp_sigval = TARGET_SIGNAL_ILL;  break;

    case SPR_DRR_IE:    rsp_sigval = TARGET_SIGNAL_INT;  break;

    case SPR_DRR_DME:   rsp_sigval = TARGET_SIGNAL_SEGV; break;

    case SPR_DRR_IME:   rsp_sigval = TARGET_SIGNAL_SEGV; break;

    case SPR_DRR_RE:    rsp_sigval = TARGET_SIGNAL_FPE;  break;

    case SPR_DRR_SCE:   rsp_sigval = TARGET_SIGNAL_USR2; break;

    case SPR_DRR_FPE:   rsp_sigval = TARGET_SIGNAL_FPE;  break;

    case SPR_DRR_TE:    rsp_sigval = TARGET_SIGNAL_TRAP; break;

    default:

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

      rsp_sigval = TARGET_SIGNAL_TRAP; break;

    }

  return;

}

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

//! Send a packet acknowledging an exception has occurred

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

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

void

GdbServerSC::rspReportException ()

{

  // Construct a signal received packet

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

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

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

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

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

  rsp->putPkt (pkt);

}       // rspReportException ()

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

//! Handle a RSP continue request

//! 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.

//! At present other exceptions are not supported

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

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

void

GdbServerSC::rspContinue (uint32_t   except)

{

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

  // Reject all except 'c' packets

  if ('c' != pkt->data[0])

    {

      cerr << "Warning: Continue with signal not currently supported: "

           << "ignored" << endl;

      return;

    }

  // Get an address if we have one

  if (0 == strcmp ("c", pkt->data))

    {

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

    }

  else if (1 != sscanf (pkt->data, "c%lx", &addr))

    {

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

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

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

    }

  rspContinue (addr, EXCEPT_NONE);

}       // rspContinue ()

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

//! Handle a RSP continue with signal request

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

//!       function. 

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

void

GdbServerSC::rspContinue ()

{

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

       << "' received" << endl;

}       // rspContinue ()

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

//! Generic processing of a continue request

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

//! handled. Currently the exception is ignored.

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

//! processor is unstalled.

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

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

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

void

GdbServerSC::rspContinue (uint32_t  addr,

                          uint32_t  except)

{

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

  writeNpc (addr);

  /*

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

  // ... actually no, I was wrong about this.

  if (NULL != mpHash->lookup (BP_MEMORY, addr) && rsp_sigval == TARGET_SIGNAL_TRAP)

    {

      MpEntry *entry = mpHash->lookup (BP_MEMORY, addr);

      debugUnit->writeMem32(entry->addr, entry->instr);

    }

  */

  // Clear Debug Reason Register and watchpoint break generation in Debug Mode

  // Register 2 for watchpoints that we triggered to stop this time.

  debugUnit->writeSpr (SPR_DRR,  0);

  if (rsp_sigval == TARGET_SIGNAL_TRAP)

    {

      /*

         Disable last trap generation on watchpoint if this is why we stopped

         last time.

      */

      uint32_t temp_dmr2 = debugUnit->readSpr (SPR_DMR2);

      if (temp_dmr2 & SPR_DMR2_WBS)

        {

          /*

             One of these breakpoints is responsible for our stopping, so

             disable it this time we start. GDB will send a packet re-enabling

             it next time we continue.

          */

          debugUnit->writeSpr (SPR_DMR2, temp_dmr2 & ~((temp_dmr2&SPR_DMR2_WBS)>>10));

        }

    }

  // Clear the single step trigger in Debug Mode Register 1 and set traps to

  // be handled by the debug unit in the Debug Stop Register

  debugUnit->andSpr (SPR_DMR1, ~SPR_DMR1_ST);

  debugUnit->orSpr ( SPR_DSR,  SPR_DSR_TE);

  // Unstall the processor. Note the GDB client is now waiting for a reply,

  // which it will get as soon as the processor stalls again.

  debugUnit->unstall ();

  targetStopped = false;

}       // rspContinue ()

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

//!Handle an interrupt from GDB

//! Detect an interrupt from GDB and stall the processor                        

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

void

GdbServerSC::rspInterrupt()

{

  unsigned char  c;

  c = rsp->getRspChar();

  if (c < 0)

    {

      // Had issues, just return

      return;

    }

  // Ensure this is a ETX control char (0x3), currently, we only call this

  // function when we've peeked and seen it, otherwise, ignore, return and pray

  // things go back to normal...

  if (c != 0x03)

    {

      cerr << "* Warning: Interrupt character expected but not found on socket" << endl;

      return;

    }

  // Otherwise, it's an interrupt packet, stall the processor, and upon return

  // to the main handle_rsp() loop, it will inform GDB.

  debugUnit->stall ();

  // Send a stop reply response, manually set rsp.sigval to TARGET_SIGNAL_NONE

  rsp_sigval = TARGET_SIGNAL_NONE;

  rspReportException();

  return;

}

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

//! Handle a RSP read all registers request

//! The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! returned as a sequence of bytes in target endian order.

//! Each byte is packed as a pair of hex digits.                             

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

void

GdbServerSC::rspReadAllRegs ()

{

  // The GPRs

  for (int  r = 0; r < max_gprs; r++)

    {

      Utils::reg2Hex (readGpr (r), &(pkt->data[r * 8]));

    }

  // PPC, NPC and SR

  Utils::reg2Hex (debugUnit->readSpr (SPR_PPC), &(pkt->data[PPC_REGNUM * 8]));

  Utils::reg2Hex (readNpc (),                   &(pkt->data[NPC_REGNUM * 8]));

  Utils::reg2Hex (debugUnit->readSpr (SPR_SR),  &(pkt->data[SR_REGNUM  * 8]));

  // Finalize the packet and send it

  pkt->data[NUM_REGS * 8] = 0;

  pkt->setLen (NUM_REGS * 8);

  rsp->putPkt (pkt);

}       // rspReadAllRegs ()

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

//! Handle a RSP write all registers request

//! The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! supplied as a sequence of bytes in target endian order.

//! Each byte is packed as a pair of hex digits.

//! @todo There is no error checking at present. Non-hex chars will generate a

//!       warning message, but there is no other check that the right amount

//!       of data is present. The result is always "OK".

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

void

GdbServerSC::rspWriteAllRegs ()

{

  // The GPRs

  for (int  r = 0; r < max_gprs; r++)

    {

      writeGpr (r, Utils::hex2Reg (&(pkt->data[r * 8])));

    }

  // PPC, NPC and SR

  debugUnit->writeSpr (SPR_PPC, Utils::hex2Reg (&(pkt->data[PPC_REGNUM * 8])));

  debugUnit->writeSpr (SPR_SR,  Utils::hex2Reg (&(pkt->data[SR_REGNUM  * 8])));

  writeNpc (                    Utils::hex2Reg (&(pkt->data[NPC_REGNUM * 8])));