Subversion Repositories openrisc

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

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