src/base/remote_gdb.hh

   1 /*
   2  * Copyright (c) 2002-2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Authors: Nathan Binkert
  29  */
  30
  31 #ifndef __REMOTE_GDB_HH__
  32 #define __REMOTE_GDB_HH__
  33
  34 #include <map>
  35 #include <sys/signal.h>
  36
  37 #include "arch/types.hh"
  38 #include "cpu/pc_event.hh"
  39 #include "base/pollevent.hh"
  40 #include "base/socket.hh"
  41
  42 class System;
  43 class ThreadContext;
  44 class PhysicalMemory;
  45
  46 class GDBListener;
  47
  48 enum GDBCommands
  49 {
  50     GDBSignal              = '?', // last signal
  51     GDBSetBaud             = 'b', // set baud (depracated)
  52     GDBSetBreak            = 'B', // set breakpoint (depracated)
  53     GDBCont                = 'c', // resume
  54     GDBAsyncCont           = 'C', // continue with signal
  55     GDBDebug               = 'd', // toggle debug flags (deprecated)
  56     GDBDetach              = 'D', // detach remote gdb
  57     GDBRegR                = 'g', // read general registers
  58     GDBRegW                = 'G', // write general registers
  59     GDBSetThread           = 'H', // set thread
  60     GDBCycleStep           = 'i', // step a single cycle
  61     GDBSigCycleStep        = 'I', // signal then cycle step
  62     GDBKill                = 'k', // kill program
  63     GDBMemR                = 'm', // read memory
  64     GDBMemW                = 'M', // write memory
  65     GDBReadReg             = 'p', // read register
  66     GDBSetReg              = 'P', // write register
  67     GDBQueryVar            = 'q', // query variable
  68     GDBSetVar              = 'Q', // set variable
  69     GDBReset               = 'r', // reset system.  (Deprecated)
  70     GDBStep                = 's', // step
  71     GDBAsyncStep           = 'S', // signal and step
  72     GDBThreadAlive         = 'T', // find out if the thread is alive
  73     GDBTargetExit          = 'W', // target exited
  74     GDBBinaryDload         = 'X', // write memory
  75     GDBClrHwBkpt           = 'z', // remove breakpoint or watchpoint
  76     GDBSetHwBkpt           = 'Z'  // insert breakpoint or watchpoint
  77 };
  78
  79 const char GDBStart = '$';
  80 const char GDBEnd = '#';
  81 const char GDBGoodP = '+';
  82 const char GDBBadP = '-';
  83
  84 const int GDBPacketBufLen = 1024;
  85
  86 class BaseRemoteGDB
  87 {
  88   private:
  89     friend void debugger();
  90     friend class GDBListener;
  91
  92     //Helper functions
  93   protected:
  94     int digit2i(char);
  95     char i2digit(int);
  96     Addr hex2i(const char **);
  97     //Address formats, break types, and gdb commands may change
  98     //between architectures, so they're defined as virtual
  99     //functions.
 100     virtual void mem2hex(void *, const void *, int);
 101     virtual const char * hex2mem(void *, const char *, int);
 102     virtual const char * break_type(char c);
 103     virtual const char * gdb_command(char cmd);
 104
 105   protected:
 106     class Event : public PollEvent
 107     {
 108       protected:
 109         BaseRemoteGDB *gdb;
 110
 111       public:
 112         Event(BaseRemoteGDB *g, int fd, int e);
 113         void process(int revent);
 114     };
 115
 116     friend class Event;
 117     Event *event;
 118     GDBListener *listener;
 119     int number;
 120
 121   protected:
 122     //The socket commands come in through
 123     int fd;
 124
 125   protected:
 126 #ifdef notyet
 127     label_t recover;
 128 #endif
 129     bool active;
 130     bool attached;
 131
 132     System *system;
 133     PhysicalMemory *pmem;
 134     ThreadContext *context;
 135
 136   protected:
 137     class GdbRegCache
 138     {
 139       public:
 140         GdbRegCache(size_t newSize) : regs(new uint64_t[newSize]), size(newSize)
 141         {}
 142         ~GdbRegCache()
 143         {
 144             delete [] regs;
 145         }
 146
 147         uint64_t * regs;
 148         size_t size;
 149         size_t bytes() { return size * sizeof(uint64_t); }
 150     };
 151
 152     GdbRegCache gdbregs;
 153
 154   protected:
 155     uint8_t getbyte();
 156     void putbyte(uint8_t b);
 157
 158     int recv(char *data, int len);
 159     void send(const char *data);
 160
 161   protected:
 162     // Machine memory
 163     virtual bool read(Addr addr, size_t size, char *data);
 164     virtual bool write(Addr addr, size_t size, const char *data);
 165
 166     template <class T> T read(Addr addr);
 167     template <class T> void write(Addr addr, T data);
 168
 169   public:
 170     BaseRemoteGDB(System *system, ThreadContext *context, size_t cacheSize);
 171     virtual ~BaseRemoteGDB();
 172
 173     void replaceThreadContext(ThreadContext *tc) { context = tc; }
 174
 175     void attach(int fd);
 176     void detach();
 177     bool isattached();
 178
 179     virtual bool acc(Addr addr, size_t len) = 0;
 180     bool trap(int type);
 181     virtual bool breakpoint()
 182     {
 183         return trap(SIGTRAP);
 184     }
 185
 186   protected:
 187     virtual void getregs() = 0;
 188     virtual void setregs() = 0;
 189
 190     virtual void clearSingleStep() = 0;
 191     virtual void setSingleStep() = 0;
 192
 193     PCEventQueue *getPcEventQueue();
 194
 195   protected:
 196     class HardBreakpoint : public PCEvent
 197     {
 198       private:
 199         BaseRemoteGDB *gdb;
 200
 201       public:
 202         int refcount;
 203
 204       public:
 205         HardBreakpoint(BaseRemoteGDB *_gdb, Addr addr);
 206         std::string name() { return gdb->name() + ".hwbkpt"; }
 207
 208         virtual void process(ThreadContext *tc);
 209     };
 210     friend class HardBreakpoint;
 211
 212     typedef std::map<Addr, HardBreakpoint *> break_map_t;
 213     typedef break_map_t::iterator break_iter_t;
 214     break_map_t hardBreakMap;
 215
 216     bool insertSoftBreak(Addr addr, size_t len);
 217     bool removeSoftBreak(Addr addr, size_t len);
 218     bool insertHardBreak(Addr addr, size_t len);
 219     bool removeHardBreak(Addr addr, size_t len);
 220
 221   protected:
 222     void clearTempBreakpoint(Addr &bkpt);
 223     void setTempBreakpoint(Addr bkpt);
 224
 225   public:
 226     std::string name();
 227 };
 228
 229 template <class T>
 230 inline T
 231 BaseRemoteGDB::read(Addr addr)
 232 {
 233     T temp;
 234     read(addr, sizeof(T), (char *)&temp);
 235     return temp;
 236 }
 237
 238 template <class T>
 239 inline void
 240 BaseRemoteGDB::write(Addr addr, T data)
 241 { write(addr, sizeof(T), (const char *)&data); }
 242
 243 class GDBListener
 244 {
 245   protected:
 246     class Event : public PollEvent
 247     {
 248       protected:
 249         GDBListener *listener;
 250
 251       public:
 252         Event(GDBListener *l, int fd, int e);
 253         void process(int revent);
 254     };
 255
 256     friend class Event;
 257     Event *event;
 258
 259   protected:
 260     ListenSocket listener;
 261     BaseRemoteGDB *gdb;
 262     int port;
 263
 264   public:
 265     GDBListener(BaseRemoteGDB *g, int p);
 266     ~GDBListener();
 267
 268     void accept();
 269     void listen();
 270     std::string name();
 271 };
 272
 273 #endif /* __REMOTE_GDB_H__ */