projects / thirdparty / binutils-gdb.git / blame
| Commit | Line | Data |
|---|---|---|
| 3a9c3d12 NC |
1 | /* |
| 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$ | |
| 15 | * Checkin $Date$ | |
| 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 |