summaryrefslogtreecommitdiff
path: root/src/base/remote_gdb.hh
blob: 4a1754afd0f9030d6ba3d762ef4b64d44cccc35b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
/*
 * Copyright (c) 2002-2005 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors: Nathan Binkert
 */

#ifndef __REMOTE_GDB_HH__
#define __REMOTE_GDB_HH__

#include <map>

#include "arch/types.hh"
#include "cpu/pc_event.hh"
#include "base/pollevent.hh"
#include "base/socket.hh"

class System;
class ThreadContext;
class PhysicalMemory;

class GDBListener;

enum GDBCommands
{
    GDBSignal              = '?', // last signal
    GDBSetBaud             = 'b', // set baud (depracated)
    GDBSetBreak            = 'B', // set breakpoint (depracated)
    GDBCont                = 'c', // resume
    GDBAsyncCont           = 'C', // continue with signal
    GDBDebug               = 'd', // toggle debug flags (deprecated)
    GDBDetach              = 'D', // detach remote gdb
    GDBRegR                = 'g', // read general registers
    GDBRegW                = 'G', // write general registers
    GDBSetThread           = 'H', // set thread
    GDBCycleStep           = 'i', // step a single cycle
    GDBSigCycleStep        = 'I', // signal then cycle step
    GDBKill                = 'k', // kill program
    GDBMemR                = 'm', // read memory
    GDBMemW                = 'M', // write memory
    GDBReadReg             = 'p', // read register
    GDBSetReg              = 'P', // write register
    GDBQueryVar            = 'q', // query variable
    GDBSetVar              = 'Q', // set variable
    GDBReset               = 'r', // reset system.  (Deprecated)
    GDBStep                = 's', // step
    GDBAsyncStep           = 'S', // signal and step
    GDBThreadAlive         = 'T', // find out if the thread is alive
    GDBTargetExit          = 'W', // target exited
    GDBBinaryDload         = 'X', // write memory
    GDBClrHwBkpt           = 'z', // remove breakpoint or watchpoint
    GDBSetHwBkpt           = 'Z'  // insert breakpoint or watchpoint
};

const char GDBStart = '$';
const char GDBEnd = '#';
const char GDBGoodP = '+';
const char GDBBadP = '-';

const int GDBPacketBufLen = 1024;

class BaseRemoteGDB
{
  private:
    friend void debugger();
    friend class GDBListener;

    //Helper functions
  protected:
    int digit2i(char);
    char i2digit(int);
    Addr hex2i(const char **);
    //Address formats, break types, and gdb commands may change
    //between architectures, so they're defined as virtual
    //functions.
    virtual void mem2hex(void *, const void *, int);
    virtual const char * hex2mem(void *, const char *, int);
    virtual const char * break_type(char c);
    virtual const char * gdb_command(char cmd);

  protected:
    class Event : public PollEvent
    {
      protected:
        BaseRemoteGDB *gdb;

      public:
        Event(BaseRemoteGDB *g, int fd, int e);
        void process(int revent);
    };

    friend class Event;
    Event *event;
    GDBListener *listener;
    int number;

  protected:
    //The socket commands come in through
    int fd;

  protected:
#ifdef notyet
    label_t recover;
#endif
    bool active;
    bool attached;

    System *system;
    PhysicalMemory *pmem;
    ThreadContext *context;

  protected:
    class GdbRegCache
    {
      public:
        GdbRegCache(size_t newSize) : regs(new uint64_t[newSize]), size(newSize)
        {}
        ~GdbRegCache()
        {
            delete [] regs;
        }

        uint64_t * regs;
        size_t size;
    };

    GdbRegCache gdbregs;

  protected:
    uint8_t getbyte();
    void putbyte(uint8_t b);

    int recv(char *data, int len);
    void send(const char *data);

  protected:
    // Machine memory
    virtual bool read(Addr addr, size_t size, char *data);
    virtual bool write(Addr addr, size_t size, const char *data);

    template <class T> T read(Addr addr);
    template <class T> void write(Addr addr, T data);

  public:
    BaseRemoteGDB(System *system, ThreadContext *context, size_t cacheSize);
    virtual ~BaseRemoteGDB();

    void replaceThreadContext(ThreadContext *tc) { context = tc; }

    void attach(int fd);
    void detach();
    bool isattached();

    virtual bool acc(Addr addr, size_t len) = 0;
    bool trap(int type);

  protected:
    virtual void getregs() = 0;
    virtual void setregs() = 0;

    virtual void clearSingleStep() = 0;
    virtual void setSingleStep() = 0;

    PCEventQueue *getPcEventQueue();

  protected:
    class HardBreakpoint : public PCEvent
    {
      private:
        BaseRemoteGDB *gdb;

      public:
        int refcount;

      public:
        HardBreakpoint(BaseRemoteGDB *_gdb, Addr addr);
        std::string name() { return gdb->name() + ".hwbkpt"; }

        virtual void process(ThreadContext *tc);
    };
    friend class HardBreakpoint;

    typedef std::map<Addr, HardBreakpoint *> break_map_t;
    typedef break_map_t::iterator break_iter_t;
    break_map_t hardBreakMap;

    bool insertSoftBreak(Addr addr, size_t len);
    bool removeSoftBreak(Addr addr, size_t len);
    bool insertHardBreak(Addr addr, size_t len);
    bool removeHardBreak(Addr addr, size_t len);

  protected:
    void clearTempBreakpoint(Addr &bkpt);
    void setTempBreakpoint(Addr bkpt);

  public:
    std::string name();
};

template <class T>
inline T
BaseRemoteGDB::read(Addr addr)
{
    T temp;
    read(addr, sizeof(T), (char *)&temp);
    return temp;
}

template <class T>
inline void
BaseRemoteGDB::write(Addr addr, T data)
{ write(addr, sizeof(T), (const char *)&data); }

class GDBListener
{
  protected:
    class Event : public PollEvent
    {
      protected:
        GDBListener *listener;

      public:
        Event(GDBListener *l, int fd, int e);
        void process(int revent);
    };

    friend class Event;
    Event *event;

  protected:
    ListenSocket listener;
    BaseRemoteGDB *gdb;
    int port;

  public:
    GDBListener(BaseRemoteGDB *g, int p);
    ~GDBListener();

    void accept();
    void listen();
    std::string name();
};

#endif /* __REMOTE_GDB_H__ */