Reversion of the non-dyn-detail version from merge
[dyninst.git] / external / bluegene / debugger_interface.h
1 /* begin_generated_IBM_copyright_prolog                             */
2 /*                                                                  */
3 /* This is an automatically generated copyright prolog.             */
4 /* After initializing, DO NOT MODIFY OR MOVE                        */
5 /* ---------------------------------------------------------------- */
6 /* IBM Confidential                                                 */
7 /*                                                                  */
8 /* OCO Source Materials                                             */
9 /*                                                                  */
10 /* Product(s):                                                      */
11 /* 5733-BG1                                                         */
12 /*                                                                  */
13 /* (C)Copyright IBM Corp. 2004, 2004                                */
14 /*                                                                  */
15 /* The Source code for this program is not published or otherwise   */
16 /* divested of its trade secrets, irrespective of what has been     */
17 /* deposited with the U.S. Copyright Office.                        */
18 /* ---------------------------------------------------------------  */
19 /*                                                                  */
20 /* end_generated_IBM_copyright_prolog                               */
21 #ifndef DEBUGGER_INTERFACE_H
22 #define DEBUGGER_INTERFACE_H
23 #include <stdint.h>
24 #include <stdio.h>
25 namespace DebuggerInterface {
26 #define BGL_DEBUGGER_WRITE_PIPE 3
27 #define BGL_DEBUGGER_READ_PIPE 4
28    // Some typedefs to insure consistency later.
29    typedef uint32_t BGL_NodeNum_t; // Which compute node under an I/O node
30    typedef uint32_t BGL_ThreadID_t; // Which thread in the compute node
31    typedef uint32_t BGL_GPR_t; // GPRs are 32 bit unsigned
32    typedef uint32_t BGL_Addr_t; // 32 bit virtual address
33    /* Register numbers
34       The value of each enum is magically the same as the offset in
35       words into the GPRSet_t structure. The system is similar to,
36       but not necessarily the same as used by ptrace.h.
37    */
38    typedef enum {
39       BGL_GPR0 = 0,
40       BGL_GPR1,
41       BGL_GPR2,
42       BGL_GPR3,
43       BGL_GPR4,
44       BGL_GPR5,
45       BGL_GPR6,
46       BGL_GPR7,
47       BGL_GPR8,
48       BGL_GPR9,
49       BGL_GPR10,
50       BGL_GPR11,
51       BGL_GPR12,
52       BGL_GPR13,
53       BGL_GPR14,
54       BGL_GPR15,
55       BGL_GPR16,
56       BGL_GPR17,
57       BGL_GPR18,
58       BGL_GPR19,
59       BGL_GPR20,
60       BGL_GPR21,
61       BGL_GPR22,
62       BGL_GPR23,
63       BGL_GPR24,
64       BGL_GPR25,
65       BGL_GPR26,
66       BGL_GPR27,
67       BGL_GPR28,
68       BGL_GPR29,
69       BGL_GPR30,
70       BGL_GPR31 = 31,
71       BGL_FPSCR = 32,
72       BGL_LR = 33,
73       BGL_CR = 34,
74       BGL_XER = 35,
75       BGL_CTR = 36,
76       BGL_IAR = 37,
77       BGL_MSR = 38,
78       BGL_DEAR = 39,
79       BGL_ESR = 40
80    } BGL_GPR_Num_t;
81    /* Floating point register numbers
82       We have 'double hummer'. We will pretend that we have 32 registers,
83       each 128 bits (4 words) wide. Once again, the enum value is the
84       offset into the FPRSet_t struct.
85    */
86    typedef enum {
87       BGL_FPR0 = 0,
88       BGL_FPR1,
89       BGL_FPR2,
90       BGL_FPR3,
91       BGL_FPR4,
92       BGL_FPR5,
93       BGL_FPR6,
94       BGL_FPR7,
95       BGL_FPR8,
96       BGL_FPR9,
97       BGL_FPR10,
98       BGL_FPR11,
99       BGL_FPR12,
100       BGL_FPR13,
101       BGL_FPR14,
102       BGL_FPR15,
103       BGL_FPR16,
104       BGL_FPR17,
105       BGL_FPR18,
106       BGL_FPR19,
107       BGL_FPR20,
108       BGL_FPR21,
109       BGL_FPR22,
110       BGL_FPR23,
111       BGL_FPR24,
112       BGL_FPR25,
113       BGL_FPR26,
114       BGL_FPR27,
115       BGL_FPR28,
116       BGL_FPR29,
117       BGL_FPR30,
118       BGL_FPR31 = 31
119    } BGL_FPR_Num_t;
120    /* MsgType
121       This doesn't match the ptrace interface very well.
122       Ptrace doesn't define most of these primitives.
123       Therefore, the enums are completely arbitrary.
124       Notice that except for SIGNAL_ENCOUNTERED, each
125       request from the debugger has a corresponding
126       acknowledgement message.
127    */
128    typedef enum { GET_REG,
129                   GET_ALL_REGS, // request gprs and other non-fp regs
130                   SET_REG, // set a specific register
131                   GET_MEM, // get memory values
132                   SET_MEM, // set memory
133                   GET_FLOAT_REG, //5
134                   GET_ALL_FLOAT_REGS,
135                   SET_FLOAT_REG,
136                   SINGLE_STEP, // step one instruction
137                   CONTINUE, // tell compute node to continue running
138                   KILL, // 10 send a signal w/ implicit continue
139                   ATTACH, // mark compute node
140                   DETACH, // unmark compute node
141                   GET_REG_ACK,
142                   GET_ALL_REGS_ACK, // sent when compute node responds
143                   SET_REG_ACK, // 15 send when compute node responds
144                   GET_MEM_ACK, // sent when compute node responds
145                   SET_MEM_ACK, // sent when compute node responds
146                   GET_FLOAT_REG_ACK,
147                   GET_ALL_FLOAT_REGS_ACK,
148                   SET_FLOAT_REG_ACK, //20
149                   SINGLE_STEP_ACK, // sent when compute node completes step
150                   CONTINUE_ACK, // sent when compute node is told
151                   KILL_ACK, // send when signal is sent
152                   ATTACH_ACK, // sent after compute node is marked
153                   DETACH_ACK, // 25 sent after compute node is unmarked
154                   SIGNAL_ENCOUNTERED, // sent when a signal is encountered
155                   PROGRAM_EXITED, // with implicit detach
156                   VERSION_MSG,
157                   VERSION_MSG_ACK,
158                   GET_DEBUG_REGS, //30
159                   GET_DEBUG_REGS_ACK,
160                   SET_DEBUG_REGS,
161                   SET_DEBUG_REGS_ACK,
162                   THIS_SPACE_FOR_RENT
163    } BGL_MsgType_t;
164    extern const char *BGL_Packet_Names[];
165    /* GPRSet_t
166       This is the set of general purpose registers.
167    */
168    typedef struct {
169       uint32_t gpr[32]; // gprs
170       uint32_t fpscr; // fpscr
171       uint32_t lr; // link
172       uint32_t cr; // condition reg
173       uint32_t xer; // xer
174       uint32_t ctr; // count register
175       uint32_t iar; // pc
176       uint32_t msr; // machine status register
177       uint32_t dear; // data exception address register
178       uint32_t esr; // exception syndrome register
179    } BGL_GPRSet_t;
180    /* FPRSet_t
181       Our FPRs are a little bit different because of the double hummer.
182       We actually have 2 sets of FPRs.
183       The convention that we'll use is to treat the FPRs as one set of
184       32, with each FPR being four words instead of two.
185    */
186    typedef struct {
187       uint32_t w0; // First word of FPR in first FPR set
188       uint32_t w1; // Second word of FPR in first FPR set
189       uint32_t w2; // First word of FPR in second FPR set
190       uint32_t w3; // Second word of FPR in second FPR set
191    } BGL_FPR_t;
192    typedef struct {
193       BGL_FPR_t fprs[32];
194    } BGL_FPRSet_t;
195    typedef struct {
196       uint32_t DBCR0; // Debug Control Register 0
197       uint32_t DBCR1; // Debug Control Register 1
198       uint32_t DBCR2; // Debug Control Register 2
199       uint32_t DBSR; // Debug Status Register
200       uint32_t IAC1; // Instruction Address Compare Register 1
201       uint32_t IAC2; // Instruction Address Compare Register 2
202       uint32_t IAC3; // Instruction Address Compare Register 3
203       uint32_t IAC4; // Instruction Address Compare Register 4
204       uint32_t DAC1; // Data Address Compare Register 1
205       uint32_t DAC2; // Data Address Compare Register 2
206       uint32_t DVC1; // Data Value Compare Register 1
207       uint32_t DVC2; // Data Value Compare Register 2
208    } BGL_DebugSet_t;
209    typedef enum {
210       RC_NO_ERROR = 0,
211       RC_NOT_ATTACHED = 1,
212       RC_NOT_RUNNING = 2,
213       RC_BAD_NODE = 3,
214       RC_BAD_THREAD = 4,
215       RC_BAD_COMMAND = 5,
216       RC_BAD_REGISTER = 6,
217       RC_NOT_APP_SPACE = 7,
218       RC_LEN_TOO_LONG = 8,
219       RC_DENIED = 9,
220       RC_BAD_SIGNAL = 10,
221       RC_NOT_STOPPED = 11
222    } BGL_ErrorCode_t;
223    /* Debugger_Msg_t
224       This is the packet header for the pipe. All messages use this.
225       messageType is self explanatory
226       nodeNumber is the target compute node
227       thread is the thread on the compute node
228       sequence can be used to keep track of packet flow
229       returnCode might be needed
230       dataLength is the size in chars of the payload
231       The 'payload' should follow the message header, and be received
232       into a buffer of size dataLength.
233       Not all messages have payloads. If your message doesn't have
234       a payload, set dataLength to 0.
235       'sequence' is probably best used as a 'packet count' or a sequence
236       number. This way you can match acknowledgement packets with the
237       original packet if things aren't being done in lockstep.
238       'returnCode' isn't architected yet, but we probably need it. If your
239       GET_MEM request fails how else will you know?
240       'dataStartsHere' is a placeholder. As a result, to get the true size
241       of this data structure you have to subtract 1 byte.
242    */
243 #define BGL_Debugger_Msg_MAX_SIZE 4096
244 #define BGL_Debugger_Msg_HEADER_SIZE 24
245 #define BGL_Debugger_Msg_MAX_PAYLOAD_SIZE (BGL_Debugger_Msg_MAX_SIZE-BGL_Debugger_Msg_HEADER_SIZE)
246 #define BGL_Debugger_Msg_MAX_MEM_SIZE 4064
247    class BGL_Debugger_Msg {
248    public:
249       typedef struct {
250          BGL_MsgType_t messageType;
251          BGL_NodeNum_t nodeNumber;
252          BGL_ThreadID_t thread;
253          uint32_t sequence;
254          uint32_t returnCode;
255          uint32_t dataLength; // excluding this header
256       } Header;
257       Header header;
258       typedef union {
259          struct {
260             BGL_GPR_Num_t registerNumber;
261          } GET_REG;
262          struct {
263             BGL_GPR_Num_t registerNumber;
264             BGL_GPR_t value;
265          } GET_REG_ACK;
266          struct {
267          } GET_ALL_REGS;
268          struct {
269             BGL_GPRSet_t gprs;
270          } GET_ALL_REGS_ACK;
271          struct {
272             BGL_GPR_Num_t registerNumber;
273             BGL_GPR_t value;
274          } SET_REG;
275          struct {
276             BGL_GPR_Num_t registerNumber;
277          } SET_REG_ACK;
278          struct {
279             BGL_Addr_t addr;
280             uint32_t len;
281          } GET_MEM;
282          struct {
283             BGL_Addr_t addr;
284             uint32_t len;
285             unsigned char data[BGL_Debugger_Msg_MAX_MEM_SIZE];
286          } GET_MEM_ACK;
287          struct {
288             BGL_Addr_t addr;
289             uint32_t len;
290             unsigned char data[BGL_Debugger_Msg_MAX_MEM_SIZE];
291          } SET_MEM;
292          struct {
293             BGL_Addr_t addr;
294             uint32_t len;
295          } SET_MEM_ACK;
296          struct {
297             BGL_FPR_Num_t registerNumber;
298          } GET_FLOAT_REG;
299          struct {
300             BGL_FPR_Num_t registerNumber;
301             BGL_FPR_t value;
302          } GET_FLOAT_REG_ACK;
303          struct {
304          } GET_ALL_FLOAT_REGS;
305          struct {
306             BGL_FPRSet_t fprs;
307          } GET_ALL_FLOAT_REGS_ACK;
308          struct {
309             BGL_FPR_Num_t registerNumber;
310             BGL_FPR_t value;
311          } SET_FLOAT_REG;
312          struct {
313             BGL_FPR_Num_t registerNumber;
314          } SET_FLOAT_REG_ACK;
315          struct {
316          } SINGLE_STEP;
317          struct {
318          } SINGLE_STEP_ACK;
319          struct {
320             uint32_t signal;
321          } CONTINUE;
322          struct {
323          } CONTINUE_ACK;
324          struct {
325             uint32_t signal;
326          } KILL;
327          struct {
328          } KILL_ACK;
329          struct {
330          } ATTACH;
331          struct {
332          } ATTACH_ACK;
333          struct {
334          } DETACH;
335          struct {
336          } DETACH_ACK;
337          struct {
338             uint32_t signal;
339          } SIGNAL_ENCOUNTERED;
340          struct {
341             int32_t type; // 0 = exit, 1 = signal
342             int32_t rc;
343          } PROGRAM_EXITED;
344          struct {
345          } VERSION_MSG;
346          struct {
347             uint32_t protocolVersion;
348             uint32_t numPhysicalProcessors;
349             uint32_t numLogicalProcessors;
350          } VERSION_MSG_ACK;
351          struct {
352          } GET_DEBUG_REGS;
353          struct {
354             BGL_DebugSet_t debugRegisters;
355          } GET_DEBUG_REGS_ACK;
356          struct {
357             BGL_DebugSet_t debugRegisters;
358          } SET_DEBUG_REGS;
359          struct {
360          } SET_DEBUG_REGS_ACK;
361          unsigned char dataStartsHere;
362       } DataArea;
363       DataArea dataArea;
364       // Ctor
365       BGL_Debugger_Msg( void ) { header.messageType = THIS_SPACE_FOR_RENT; }
366       BGL_Debugger_Msg( BGL_MsgType_t type,
367                         BGL_NodeNum_t node,
368                         BGL_ThreadID_t thread,
369                         uint32_t sequence,
370                         uint32_t returnCode )
371          {
372             header.messageType = type;
373             header.nodeNumber = node;
374             header.thread = thread;
375             header.sequence = sequence;
376             header.returnCode = returnCode;
377          }
378       static BGL_Debugger_Msg generateErrorPacket( BGL_Debugger_Msg &original, BGL_ErrorCode_t ec );
379       static bool readFromFd( int fd, BGL_Debugger_Msg &msg );
380       static bool writeOnFd( int fd, BGL_Debugger_Msg &msg );
381       static void dump( BGL_Debugger_Msg &msg );
382       static void dump( BGL_Debugger_Msg &msg, FILE *outfile );
383    };
384 }
385 #endif // DEBUGGER_INTERFACE_H