OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [rdi-share/] [dbg_rdi.h] - Blame information for rev 106

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/*
2
 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
3
 *
4
 * This software may be freely used, copied, modified, and distributed
5
 * provided that the above copyright notice is preserved in all copies of the
6
 * software.
7
 */
8
 
9
/*
10
 * ARM debugger toolbox : dbg_rdi.h
11
 */
12
 
13
/*
14
 * RCS $Revision: 1.1.1.1 $
15
 * Checkin $Date: 2001-05-18 11:16:39 $
16
 */
17
 
18
#ifndef dbg_rdi__h
19
#define dbg_rdi__h
20
 
21
/***************************************************************************\
22
*                            Other RDI values                               *
23
\***************************************************************************/
24
 
25
#define RDISex_Little           0 /* the byte sex of the debuggee       */
26
#define RDISex_Big              1
27
#define RDISex_DontCare         2
28
 
29
#define RDIPoint_EQ             0 /* the different types of break/watchpoints */
30
#define RDIPoint_GT             1
31
#define RDIPoint_GE             2
32
#define RDIPoint_LT             3
33
#define RDIPoint_LE             4
34
#define RDIPoint_IN             5
35
#define RDIPoint_OUT            6
36
#define RDIPoint_MASK           7
37
 
38
#define RDIPoint_16Bit          16  /* 16-bit breakpoint                */
39
#define RDIPoint_Conditional    32
40
 
41
/* ORRed with point type in extended RDP break and watch messages       */
42
#define RDIPoint_Inquiry        64
43
#define RDIPoint_Handle         128 /* messages                         */
44
 
45
#define RDIWatch_ByteRead       1 /* types of data accesses to watch for*/
46
#define RDIWatch_HalfRead       2
47
#define RDIWatch_WordRead       4
48
#define RDIWatch_ByteWrite      8
49
#define RDIWatch_HalfWrite      16
50
#define RDIWatch_WordWrite      32
51
 
52
#define RDIReg_R15              (1L << 15) /* mask values for CPU       */
53
#define RDIReg_PC               (1L << 16)
54
#define RDIReg_CPSR             (1L << 17)
55
#define RDIReg_SPSR             (1L << 18)
56
#define RDINumCPURegs           19
57
 
58
#define RDINumCPRegs            10 /* current maximum                   */
59
 
60
#define RDIMode_Curr            255
61
 
62
/* RDI_Info subcodes */
63
/* rdp in parameters are all preceded by                                */
64
/*   in byte = RDP_Info, word = info subcode                            */
65
/*     out parameters are all preceded by                               */
66
/*   out byte = RDP_Return                                              */
67
 
68
#define RDIInfo_Target          0
69
/* rdi: out ARMword *targetflags, out ARMword *processor id             */
70
/* rdp: in none, out word targetflags, word processorid, byte status    */
71
/* the following bits are defined in targetflags                        */
72
#  define RDITarget_LogSpeed                  0x0f
73
#  define RDITarget_HW                        0x10    /* else emulator  */
74
#  define RDITarget_AgentMaxLevel             0xe0
75
#  define RDITarget_AgentLevelShift       5
76
#  define RDITarget_DebuggerMinLevel         0x700
77
#  define RDITarget_DebuggerLevelShift    8
78
#  define RDITarget_CanReloadAgent           0x800
79
#  define RDITarget_CanInquireLoadSize      0x1000
80
#  define RDITarget_UnderstandsRDPInterrupt 0x2000
81
#  define RDITarget_CanProfile              0x4000
82
#  define RDITarget_Code16                  0x8000
83
#  define RDITarget_HasCommsChannel        0x10000
84
 
85
#define RDIInfo_Points          1
86
/* rdi: out ARMword *pointcapabilities                                  */
87
/* rdp: in none, out word pointcapabilities, byte status                */
88
/* the following bits are defined in pointcapabilities                  */
89
#  define RDIPointCapability_Comparison   1
90
#  define RDIPointCapability_Range        2
91
/* 4 to 128 are RDIWatch_xx{Read,Write} left-shifted by two */
92
#  define RDIPointCapability_Mask         0x100
93
#  define RDIPointCapability_ThreadBreak  0x200
94
#  define RDIPointCapability_ThreadWatch  0x400
95
#  define RDIPointCapability_CondBreak    0x800
96
#  define RDIPointCapability_Status       0x1000 /* status enquiries available */
97
 
98
#define RDIInfo_Step            2
99
/* rdi: out ARMword *stepcapabilities                                   */
100
/* rdp: in none, out word stepcapabilities, byte status                 */
101
/* the following bits are defined in stepcapabilities                   */
102
#  define RDIStep_Multiple      1
103
#  define RDIStep_PCChange      2
104
#  define RDIStep_Single        4
105
 
106
#define RDIInfo_MMU             3
107
/* rdi: out ARMword *mmuidentity                                        */
108
/* rdp: in none, out word mmuidentity, byte status                      */
109
 
110
#define RDIInfo_DownLoad        4
111
/* Inquires whether configuration download and selection is available.  */
112
/* rdp: in none, out byte status                                        */
113
/* No argument, no return value. status == ok if available              */
114
 
115
#define RDIInfo_SemiHosting     5
116
/* Inquires whether RDISemiHosting_* RDI_Info calls are available.      */
117
/* rdp: in none, out byte status                                        */
118
/* No argument, no return value. status == ok if available              */
119
 
120
#define RDIInfo_CoPro           6
121
/* Inquires whether CoPro RDI_Info calls are available.                 */
122
/* rdp: in none, out byte status                                        */
123
/* No argument, no return value. status == ok if available              */
124
 
125
#define RDIInfo_Icebreaker      7
126
/* Inquires whether debuggee controlled by IceBreaker.                  */
127
/* rdp: in none, out byte status                                        */
128
/* No argument, no return value. status == ok if available              */
129
 
130
#define RDIMemory_Access        8
131
/* rdi: out RDI_MemAccessStats *p, in ARMword *handle                   */
132
/* rdp: in word handle                                                  */
133
/*      out word nreads, word nwrites, word sreads, word swrites,       */
134
/*          word ns, word s, byte status                                */
135
 
136
/* Get memory access information for memory block with specified handle */
137
 
138
#define RDIMemory_Map           9
139
/* rdi: in  RDI_MemDescr md[n], in ARMword *n                           */
140
/* rdp: in word n, n * {                                                */
141
/*           word handle, word start, word limit,                       */
142
/*           byte width, byte access                                    */
143
/*           word Nread_ns, word Nwrite_ns,                             */
144
/*           word Sread_ns, word Swrite_ns}                             */
145
/*      out byte status                                                 */
146
/* Sets memory characteristics.                                         */
147
 
148
#define RDISet_CPUSpeed         10
149
/* rdi: in  ARMword *speed                                              */
150
/* rdp: in word speed, out byte status                                  */
151
/* Sets CPU speed (in ns)                                               */
152
 
153
#define RDIRead_Clock           12
154
/* rdi: out ARMword *ns, out ARMword *s                                 */
155
/* rdp: in none, out word ns, word s, byte status                       */
156
/* Reads simulated time                                                 */
157
 
158
#define RDIInfo_Memory_Stats    13
159
/* Inquires whether RDI_Info codes 8-10 are available                   */
160
/* rdp: in none, out byte status                                        */
161
/* No argument, no return value. status == ok if available              */
162
 
163
/* The next two are only to be used if RDIInfo_DownLoad returned no     */
164
/* error                                                                */
165
#define RDIConfig_Count         14
166
/* rdi: out ARMword *count                                              */
167
/* rdp: out byte status, word count (if status == OK)                   */
168
 
169
/* In addition, the next one is only to be used if RDIConfig_Count      */
170
/* returned no error                                                    */
171
typedef struct { unsigned32 version; char name[32]; } RDI_ConfigDesc;
172
#define RDIConfig_Nth           15
173
/* rdi: in ARMword *n, out RDI_ConfigDesc *                             */
174
/* rdp: in word n                                                       */
175
/*      out word version, byte namelen, bytes * bytelen name,           */
176
/*          byte status                                                 */
177
 
178
/* Set a front-end polling function to be used from within driver poll  */
179
/* loops                                                                */
180
typedef void RDI_PollProc(void *);
181
typedef struct { RDI_PollProc *p; void *arg; } RDI_PollDesc;
182
#define RDISet_PollProc         16
183
/* rdi: in RDI_PollDesc const *from, RDI_PollDesc *to                   */
184
/*      if from non-NULL, sets the polling function from it             */
185
/*      if to non-NULL, returns the previous polling function to it     */
186
/* No corresponding RDP operation                                       */
187
 
188
/* Called on debugger startup to see if the target is ready to execute  */
189
#define RDIInfo_CanTargetExecute 20
190
/* rdi: in  void
191
 *      out byte status (RDIError_NoError => Yes, Otherwise No)
192
 */
193
 
194
/* Called to set the top of target memory in an ICEman2 system
195
 * This is then used by ICEman to tell the C Library via the INFOHEAP
196
 * SWI where the stack should start.
197
 * Note that only ICEman2 supports this call.  Other systems eg.
198
 * Demon, Angel, will simply return an error, which means that setting
199
 * the top of memory in this fashion is not supported.
200
 */
201
#define RDIInfo_SetTopMem        21
202
/* rdi: in  word mem_top
203
 *      out byte status (RDIError_NoError => Done, Other => Not supported
204
 */
205
 
206
/* Called before performing a loadagent to determine the endianess of
207
 * the debug agent, so that images of the wrong bytesex can be
208
 * complained about
209
 */
210
#define RDIInfo_AgentEndianess   22
211
/* rdi: in void
212
 *      out byte status
213
 *      status should be RDIError_LittleEndian or RDIError_BigEndian
214
 *      any other value indicates the target does not support this
215
 *      request, so the debugger will have to make a best guess, which
216
 *      probably means only allow little endian loadagenting.
217
 */
218
 
219
/* The next two are only to be used if the value returned by            */
220
/* RDIInfo_Points has RDIPointCapability_Status set.                    */
221
#define RDIPointStatus_Watch    0x80
222
#define RDIPointStatus_Break    0x81
223
/* rdi: inout ARMword * (in handle, out hwresource), out ARMword *type  */
224
/* rdp: in word handle, out word hwresource, word type, byte status     */
225
 
226
#define RDISignal_Stop          0x100
227
/* Requests that the debuggee stop                                      */
228
/* No arguments, no return value                                        */
229
/* rdp: no reply (when the debuggee stops, there will be a reply to the */
230
/*      step or execute request which started it)                       */
231
 
232
#define RDIVector_Catch         0x180
233
/* rdi: in ARMword *bitmap                                              */
234
/* rdp: int word bitmap, out byte status                                */
235
/* bit i in bitmap set to cause vector i to cause entry to debugger     */
236
 
237
/* The next four are only to be used if RDIInfo_Semihosting returned    */
238
/* no error                                                             */
239
#define RDISemiHosting_SetState 0x181
240
/* rdi: in ARMword *semihostingstate                                    */
241
/* rdp: in word semihostingstate, out byte status                       */
242
#define RDISemiHosting_GetState 0x182
243
/* rdi: out ARMword *semihostingstate                                   */
244
/* rdp: in none, out word semihostingstate, byte status                 */
245
#define RDISemiHosting_SetVector 0x183
246
/* rdi: in ARMword *semihostingvector                                   */
247
/* rdp: in word semihostingvector, out byte status                      */
248
#define RDISemiHosting_GetVector 0x184
249
/* rdi: out ARMword *semihostingvector                                  */
250
/* rdp: in none, out word semihostingvector, byte status                */
251
 
252
/* The next two are only to be used if RDIInfo_Icebreaker returned      */
253
/* no error                                                             */
254
#define RDIIcebreaker_GetLocks  0x185
255
/* rdi: out ARMword *lockedstate                                        */
256
/* rdp: in none, out word lockedstate, byte status                      */
257
 
258
#define RDIIcebreaker_SetLocks  0x186
259
/* rdi: in ARMword *lockedstate                                         */
260
/* rdp: in word lockedstate, out byte status                            */
261
 
262
/* lockedstate is a bitmap of the icebreaker registers locked against   */
263
/* use by IceMan (because explicitly written by the user)               */
264
 
265
#define RDIInfo_GetLoadSize     0x187
266
/* rdi: out ARMword *maxloadsize                                        */
267
/* rdp: in none, out word maxloadsize, byte status                      */
268
/* Inquires the maximum length of data transfer the agent is prepared   */
269
/* to receive                                                           */
270
/* Only usable if RDIInfo_Target returned RDITarget_CanInquireLoadSize  */
271
/* rdi: out ARMword *size                                               */
272
 
273
/* Only to be used if the value returned by RDIInfo_Target had          */
274
/* RDITarget_HasCommsChannel set                                        */
275
typedef void RDICCProc_ToHost(void *arg, ARMword data);
276
typedef void RDICCProc_FromHost(void *arg, ARMword *data, int *valid);
277
 
278
#define RDICommsChannel_ToHost  0x188
279
/* rdi: in RDICCProc_ToHost *, in void *arg                             */
280
/* rdp: in byte connect, out byte status                                */
281
#define RDICommsChannel_FromHost 0x189
282
/* rdi: in RDICCProc_FromHost *, in void *arg                           */
283
/* rdp: in byte connect, out byte status                                */
284
 
285
/* These 4 are only to be used if RDIInfo_Semihosting returns no error  */
286
#define RDISemiHosting_SetARMSWI 0x190
287
/* rdi: in ARMword ARM_SWI_number                                       */
288
/* rdp: in ARMword ARM_SWI_number, out byte status                      */
289
 
290
#define RDISemiHosting_GetARMSWI 0x191
291
/* rdi: out ARMword ARM_SWI_number                                      */
292
/* rdp: out ARMword ARM_SWI_number, byte status                         */
293
 
294
#define RDISemiHosting_SetThumbSWI 0x192
295
/* rdi: in ARMword Thumb_SWI_number                                     */
296
/* rdp: in ARMword Thumb_SWI_number, out byte status                    */
297
 
298
#define RDISemiHosting_GetThumbSWI 0x193
299
/* rdi: out ARMword ARM_Thumb_number                                    */
300
/* rdp: out ARMword ARM_Thumb_number, byte status                       */
301
 
302
 
303
#define RDICycles               0x200
304
/* rdi: out ARMword cycles[12]                                          */
305
/* rdp: in none, out 6 words cycles, byte status                        */
306
/* the rdi result represents 6 big-endian doublewords; the rdp results  */
307
/* return values for the ls halves of these                             */
308
#  define RDICycles_Size        48
309
 
310
#define RDIErrorP               0x201
311
/* rdi: out ARMaddress *errorp                                          */
312
/* rdp: in none, out word errorp, byte status                           */
313
/* Returns the error pointer associated with the last return from step  */
314
/* or execute with status RDIError_Error.                               */
315
 
316
#define RDISet_Cmdline          0x300
317
/* rdi: in char *commandline (a null-terminated string)                 */
318
/* No corresponding RDP operation (cmdline is sent to the agent in      */
319
/* response to SWI_GetEnv)                                              */
320
 
321
#define RDISet_RDILevel         0x301
322
/* rdi: in ARMword *level                                               */
323
/* rdp: in word level, out byte status                                  */
324
/* Sets the RDI/RDP protocol level to be used (must lie between the     */
325
/* limits returned by RDIInfo_Target).                                  */
326
 
327
#define RDISet_Thread           0x302
328
/* rdi: in ARMword *threadhandle                                        */
329
/* rdp: in word threadhandle, out byte status                           */
330
/* Sets the thread context for subsequent thread-sensitive operations   */
331
/* (null value sets no thread)                                          */
332
 
333
/* The next two are only to be used if RDI_read or RDI_write returned   */
334
/* RDIError_LittleEndian or RDIError_BigEndian, to signify that the     */
335
/* debugger has noticed.                                                */
336
#define RDIInfo_AckByteSex  0x303
337
/* rdi: in ARMword *sex (RDISex_Little or RDISex_Big)                   */
338
 
339
/* The next two are only to be used if RDIInfo_CoPro returned no error  */
340
#define RDIInfo_DescribeCoPro   0x400
341
/* rdi: in int *cpno, Dbg_CoProDesc *cpd                                */
342
/* rdp: in byte cpno,                                                   */
343
/*         cpd->entries * {                                             */
344
/*           byte rmin, byte rmax, byte nbytes, byte access,            */
345
/*           byte cprt_r_b0, cprt_r_b1, cprt_w_b0, cprt_w_b1}           */
346
/*         byte = 255                                                   */
347
/*      out byte status                                                 */
348
 
349
#define RDIInfo_RequestCoProDesc 0x401
350
/* rdi: in int *cpno, out Dbg_CoProDesc *cpd                            */
351
/* rpd: in byte cpno                                                    */
352
/*      out nentries * {                                                */
353
/*            byte rmin, byte rmax, byte nbytes, byte access,           */
354
/*          }                                                           */
355
/*          byte = 255, byte status                                     */
356
 
357
#define RDIInfo_Log             0x800
358
/* rdi: out ARMword *logsetting                                         */
359
/* No corresponding RDP operation                                       */
360
#define RDIInfo_SetLog          0x801
361
/* rdi: in ARMword *logsetting                                          */
362
/* No corresponding RDP operation                                       */
363
 
364
#define RDIProfile_Stop         0x500
365
/* No arguments, no return value                                        */
366
/* rdp: in none, out byte status                                        */
367
/* Requests that pc sampling stop                                       */
368
 
369
#define RDIProfile_Start        0x501
370
/* rdi: in ARMword *interval                                            */
371
/* rdp: in word interval, out byte status                               */
372
/* Requests that pc sampling start, with period <interval> usec         */
373
 
374
#define RDIProfile_WriteMap     0x502
375
/* rdi: in ARMword map[]                                                */
376
/* map[0] is the length of the array, subsequent elements are sorted    */
377
/* and are the base of ranges for pc sampling (so if the sampled pc     */
378
/* lies between map[i] and map[i+1], count[i] is incremented).          */
379
/* rdp: a number of messages, each of form:                             */
380
/*        in word len, word size, word offset, <size> words map data    */
381
/*        out status                                                    */
382
/* len, size and offset are all word counts.                            */
383
 
384
#define RDIProfile_ReadMap      0x503
385
/* rdi: in ARMword *len, out ARMword counts[len]                        */
386
/* Requests that the counts array be set to the accumulated pc sample   */
387
/* counts                                                               */
388
/* rdp: a number of messages, each of form:                             */
389
/*        in word offset, word size                                     */
390
/*        out <size> words, status                                      */
391
/* len, size and offset are all word counts.                            */
392
 
393
#define RDIProfile_ClearCounts  0x504
394
/* No arguments, no return value                                        */
395
/* rdp: in none, out byte status                                        */
396
/* Requests that pc sample counts be set to zero                        */
397
 
398
#define RDIInfo_RequestReset    0x900
399
/* Request reset of the target environment                              */
400
/* No arguments, no return value                                        */
401
/* No RDP equivalent, sends an RDP reset                                */
402
 
403
#define RDIInfo_CapabilityRequest 0x8000
404
/* Request whether the interface supports the named capability. The     */
405
/* capability is specified by or'ing the RDIInfo number with this, and  */
406
/* sending that request                                                 */
407
/* rdi: in none                                                         */
408
/* rdp: in none, out byte status                                        */
409
 
410
typedef struct {
411
  ARMword len;
412
  ARMword map[1];
413
} RDI_ProfileMap;
414
 
415
typedef unsigned32 PointHandle;
416
typedef unsigned32 ThreadHandle;
417
#define RDINoPointHandle        ((PointHandle)-1L)
418
#define RDINoHandle             ((ThreadHandle)-1L)
419
 
420
struct Dbg_ConfigBlock;
421
struct Dbg_HostosInterface;
422
struct Dbg_MCState;
423
typedef int rdi_open_proc(unsigned type, struct Dbg_ConfigBlock const *config,
424
                          struct Dbg_HostosInterface const *i,
425
                          struct Dbg_MCState *dbg_state);
426
typedef int rdi_close_proc(void);
427
typedef int rdi_read_proc(ARMword source, void *dest, unsigned *nbytes);
428
typedef int rdi_write_proc(const void *source, ARMword dest, unsigned *nbytes);
429
typedef int rdi_CPUread_proc(unsigned mode, unsigned32 mask, ARMword *state);
430
typedef int rdi_CPUwrite_proc(unsigned mode, unsigned32 mask, ARMword const *state);
431
typedef int rdi_CPread_proc(unsigned CPnum, unsigned32 mask, ARMword *state);
432
typedef int rdi_CPwrite_proc(unsigned CPnum, unsigned32 mask, ARMword const *state);
433
typedef int rdi_setbreak_proc(ARMword address, unsigned type, ARMword bound,
434
                              PointHandle *handle);
435
typedef int rdi_clearbreak_proc(PointHandle handle);
436
typedef int rdi_setwatch_proc(ARMword address, unsigned type, unsigned datatype,
437
                              ARMword bound, PointHandle *handle);
438
typedef int rdi_clearwatch_proc(PointHandle handle);
439
typedef int rdi_execute_proc(PointHandle *handle);
440
typedef int rdi_step_proc(unsigned ninstr, PointHandle *handle);
441
typedef int rdi_info_proc(unsigned type, ARMword *arg1, ARMword *arg2);
442
typedef int rdi_pointinq_proc(ARMword *address, unsigned type,
443
                              unsigned datatype, ARMword *bound);
444
 
445
typedef enum {
446
    RDI_ConfigCPU,
447
    RDI_ConfigSystem
448
} RDI_ConfigAspect;
449
 
450
typedef enum {
451
    RDI_MatchAny,
452
    RDI_MatchExactly,
453
    RDI_MatchNoEarlier
454
} RDI_ConfigMatchType;
455
 
456
typedef int rdi_addconfig_proc(unsigned32 nbytes);
457
typedef int rdi_loadconfigdata_proc(unsigned32 nbytes, char const *data);
458
typedef int rdi_selectconfig_proc(RDI_ConfigAspect aspect, char const *name,
459
                                  RDI_ConfigMatchType matchtype, unsigned versionreq,
460
                                  unsigned *versionp);
461
 
462
typedef char *getbufferproc(void *getbarg, unsigned32 *sizep);
463
typedef int rdi_loadagentproc(ARMword dest, unsigned32 size, getbufferproc *getb, void *getbarg);
464
typedef int rdi_targetisdead(void);
465
 
466
typedef struct {
467
    int itemmax;
468
    char const * const *names;
469
} RDI_NameList;
470
 
471
typedef RDI_NameList const *rdi_namelistproc(void);
472
 
473
typedef int rdi_errmessproc(char *buf, int buflen, int errnum);
474
 
475
struct RDIProcVec {
476
    char rditypename[12];
477
 
478
    rdi_open_proc       *open;
479
    rdi_close_proc      *close;
480
    rdi_read_proc       *read;
481
    rdi_write_proc      *write;
482
    rdi_CPUread_proc    *CPUread;
483
    rdi_CPUwrite_proc   *CPUwrite;
484
    rdi_CPread_proc     *CPread;
485
    rdi_CPwrite_proc    *CPwrite;
486
    rdi_setbreak_proc   *setbreak;
487
    rdi_clearbreak_proc *clearbreak;
488
    rdi_setwatch_proc   *setwatch;
489
    rdi_clearwatch_proc *clearwatch;
490
    rdi_execute_proc    *execute;
491
    rdi_step_proc       *step;
492
    rdi_info_proc       *info;
493
    /* V2 RDI */
494
    rdi_pointinq_proc   *pointinquiry;
495
 
496
    /* These three useable only if RDIInfo_DownLoad returns no error */
497
    rdi_addconfig_proc  *addconfig;
498
    rdi_loadconfigdata_proc *loadconfigdata;
499
    rdi_selectconfig_proc *selectconfig;
500
 
501
    rdi_namelistproc    *drivernames;
502
    rdi_namelistproc    *cpunames;
503
 
504
    rdi_errmessproc     *errmess;
505
 
506
    /* Only if RDIInfo_Target returns a value with RDITarget_LoadAgent set */
507
    rdi_loadagentproc   *loadagent;
508
    rdi_targetisdead    *targetisdead;
509
};
510
 
511
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.