Mercurial > ecos
annotate packages/hal/common/current/src/generic-stub.c @ 136:a9ac27ec7abc ecos-sw-2000-11-17
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
| author | jlarmour |
|---|---|
| date | Fri, 17 Nov 2000 23:16:43 +0000 |
| parents | 0ae0bc38e387 |
| children | 289bf90c6a9b |
| rev | line source |
|---|---|
| 2 | 1 #include "board.h" |
| 2 | |
| 3 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS | |
| 4 | |
| 5 /* Eventually, this should default to ON */ | |
| 6 #if USE_GDBSTUB_PROTOTYPES | |
| 7 #include "stub-tservice.h" | |
| 8 #include "generic-stub.h" | |
| 9 #else | |
| 10 // Function declarations (prevents compiler warnings) | |
| 11 int stubhex (unsigned char ch); | |
| 12 static void getpacket (char *buffer); | |
| 13 static void unlock_thread_scheduler (void); | |
| 14 static uint32 crc32 (unsigned char *ptr, int len, uint32 crc); | |
| 15 #endif | |
| 16 | |
| 17 #include "thread-pkts.h" | |
| 18 /* Defines function macros if thread support is not selected in board.h */ | |
| 19 | |
| 20 | |
| 0 | 21 /**************************************************************************** |
| 22 | |
| 2 | 23 THIS SOFTWARE IS NOT COPYRIGHTED |
| 0 | 24 |
| 25 HP offers the following for use in the public domain. HP makes no | |
| 26 warranty with regard to the software or it's performance and the | |
| 27 user accepts the software "AS IS" with all faults. | |
| 28 | |
| 29 HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD | |
| 30 TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES | |
| 31 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | |
| 32 | |
| 33 ****************************************************************************/ | |
| 34 | |
| 35 /**************************************************************************** | |
| 36 * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $ | |
| 37 * | |
| 38 * Module name: remcom.c $ | |
| 39 * Revision: 1.34 $ | |
| 40 * Date: 91/03/09 12:29:49 $ | |
| 41 * Contributor: Lake Stevens Instrument Division$ | |
| 42 * | |
| 43 * Description: low level support for gdb debugger. $ | |
| 44 * | |
| 45 * Considerations: only works on target hardware $ | |
| 46 * | |
| 47 * Written by: Glenn Engel $ | |
| 48 * ModuleState: Experimental $ | |
| 49 * | |
| 50 * NOTES: See Below $ | |
| 51 * | |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
48
diff
changeset
|
52 * Modified for SPARC by Stu Grossman, Red Hat. |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
48
diff
changeset
|
53 * Modified for generic CygMON stub support by Bob Manson, Red Hat. |
| 0 | 54 * |
| 55 * To enable debugger support, two things need to happen. One, a | |
| 2 | 56 * call to set_debug_traps () is necessary in order to allow any breakpoints |
| 0 | 57 * or error conditions to be properly intercepted and reported to gdb. |
| 58 * Two, a breakpoint needs to be generated to begin communication. This | |
| 2 | 59 * is most easily accomplished by a call to breakpoint (). Breakpoint () |
| 0 | 60 * simulates a breakpoint by executing a trap #1. |
| 61 * | |
| 62 ************* | |
| 63 * | |
| 64 * The following gdb commands are supported: | |
| 65 * | |
| 66 * command function Return value | |
| 67 * | |
| 68 * g return the value of the CPU registers hex data or ENN | |
| 69 * G set the value of the CPU registers OK or ENN | |
| 70 * | |
| 71 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN | |
| 72 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN | |
| 73 * | |
| 74 * c Resume at current address SNN ( signal NN) | |
| 75 * cAA..AA Continue at address AA..AA SNN | |
| 76 * | |
| 77 * s Step one instruction SNN | |
| 78 * sAA..AA Step one instruction from AA..AA SNN | |
| 79 * | |
| 80 * k kill | |
| 81 * | |
| 82 * ? What was the last sigval ? SNN (signal NN) | |
| 83 * | |
| 2 | 84 * bBB..BB Set baud rate to BB..BB OK or BNN, then sets |
| 85 * baud rate | |
| 0 | 86 * |
| 87 * All commands and responses are sent with a packet which includes a | |
| 88 * checksum. A packet consists of | |
| 89 * | |
| 90 * $<packet info>#<checksum>. | |
| 91 * | |
| 92 * where | |
| 93 * <packet info> :: <characters representing the command or response> | |
| 94 * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>> | |
| 95 * | |
| 96 * When a packet is received, it is first acknowledged with either '+' or '-'. | |
| 97 * '+' indicates a successful transfer. '-' indicates a failed transfer. | |
| 98 * | |
| 99 * Example: | |
| 100 * | |
| 101 * Host: Reply: | |
| 102 * $m0,10#2a +$00010203040506070809101112131415#42 | |
| 103 * | |
| 104 ****************************************************************************/ | |
| 105 | |
|
48
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
106 #ifdef __ECOS__ |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
107 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
108 // We cannot share memcpy and memset with the rest of the system since |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
109 // the user may want to step through it. |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
110 static inline void* |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
111 memcpy(void* dest, void* src, int size) |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
112 { |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
113 unsigned char* __d = (unsigned char*) dest; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
114 unsigned char* __s = (unsigned char*) src; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
115 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
116 while(size--) |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
117 *__d++ = *__s++; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
118 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
119 return dest; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
120 } |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
121 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
122 static inline void* |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
123 memset(void* s, int c, int size) |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
124 { |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
125 unsigned char* __s = (unsigned char*) s; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
126 unsigned char __c = (unsigned char) c; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
127 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
128 while(size--) |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
129 *__s++ = __c; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
130 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
131 return s; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
132 } |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
133 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
134 #else |
| 2 | 135 #include <string.h> |
| 136 #include <signal.h> | |
| 137 #endif // __ECOS__ | |
| 0 | 138 |
| 139 /************************************************************************/ | |
| 140 /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/ | |
| 141 /* at least NUMREGBYTES*2 are needed for register packets */ | |
| 142 #define BUFMAX 2048 | |
| 143 | |
| 2 | 144 static int initialized = 0; /* !0 means we've been initialized */ |
| 145 | |
| 0 | 146 static int process_exception (int sigval); |
| 147 static void do_nothing (void); /* and do it gracefully */ | |
| 148 static int syscall_do_nothing (int); | |
| 2 | 149 |
| 150 void __free_program_args (void); | |
| 0 | 151 |
| 152 volatile __PFI __process_exception_vec = process_exception; | |
| 153 volatile __PFV __process_exit_vec = do_nothing; | |
| 154 volatile __PFI __process_syscall_vec = syscall_do_nothing; | |
| 155 volatile __PFI __process_signal_vec = NULL; | |
| 2 | 156 volatile __PFV __init_vec = NULL; |
| 157 volatile __PFV __cleanup_vec = NULL; | |
| 158 | |
| 159 static char *__add_program_arg (int argnum, uint32 arglen); | |
| 0 | 160 |
| 161 static const char hexchars[] = "0123456789abcdef"; | |
| 162 | |
| 2 | 163 static void process_query (char *pkt); |
| 164 static void process_set (char *pkt); | |
| 0 | 165 |
| 166 char | |
| 167 __tohex (int c) | |
| 168 { | |
| 169 return hexchars [c & 15]; | |
| 170 } | |
| 171 | |
| 2 | 172 #define __tohex(c) hexchars[(c) & 15] |
| 0 | 173 |
| 174 #ifndef NUMREGS_GDB | |
| 175 #define NUMREGS_GDB NUMREGS | |
| 176 #endif | |
| 177 | |
| 178 /* One pushback character. */ | |
| 179 int ungot_char = -1; | |
| 180 | |
| 181 static int | |
| 182 readDebugChar (void) | |
| 183 { | |
| 184 if (ungot_char > 0) | |
| 185 { | |
| 186 int result = ungot_char; | |
| 187 ungot_char = -1; | |
| 188 return result; | |
| 189 } | |
| 190 else | |
| 191 return getDebugChar (); | |
| 192 } | |
| 193 | |
| 194 /* Convert ch from a hex digit to an int. */ | |
| 195 | |
| 196 int | |
| 2 | 197 stubhex (ch) |
| 198 unsigned char ch; | |
| 0 | 199 { |
| 200 if (ch >= 'a' && ch <= 'f') | |
| 201 return ch-'a'+10; | |
| 202 if (ch >= '0' && ch <= '9') | |
| 203 return ch-'0'; | |
| 204 if (ch >= 'A' && ch <= 'F') | |
| 205 return ch-'A'+10; | |
| 206 return -1; | |
| 207 } | |
| 208 | |
| 209 static void | |
| 2 | 210 getpacket (buffer) |
| 211 char *buffer; | |
| 0 | 212 { |
| 213 struct gdb_packet packet; | |
| 214 | |
| 215 packet.state = 0; | |
| 216 packet.contents = buffer; | |
| 2 | 217 while (__add_char_to_packet (readDebugChar () & 0xff, &packet) != 1) |
| 0 | 218 { |
| 219 /* Empty */ | |
| 220 } | |
| 221 } | |
| 222 | |
| 223 int | |
| 2 | 224 __add_char_to_packet (ch, packet) |
| 225 unsigned int ch; | |
| 226 struct gdb_packet *packet; | |
| 0 | 227 { |
| 228 if (packet->state == 0) | |
| 229 { | |
| 230 if (ch == '$') | |
| 2 | 231 { |
| 232 packet->state = 1; | |
| 233 packet->length = 0; | |
| 234 packet->checksum = 0; | |
| 235 packet->xmitcsum = -1; | |
| 236 } | |
| 0 | 237 return 0; |
| 238 } | |
| 239 | |
| 240 if (packet->state == 1) | |
| 241 { | |
| 242 if (ch == '#') | |
| 2 | 243 { |
| 244 packet->contents[packet->length] = 0; | |
| 245 packet->state = 2; | |
| 246 } | |
| 0 | 247 else |
| 2 | 248 { |
| 249 if (packet->length == BUFMAX) { | |
| 250 packet->state = 0; | |
| 251 return -1; | |
| 252 } | |
| 253 packet->checksum += ch; | |
| 254 packet->contents[packet->length++] = ch; | |
| 255 } | |
| 0 | 256 return 0; |
| 257 } | |
| 258 | |
| 259 if (packet->state == 2) | |
| 260 { | |
| 261 packet->xmitcsum = stubhex (ch) << 4; | |
| 262 packet->state = 3; | |
| 263 return 0; | |
| 264 } | |
| 265 | |
| 266 if (packet->state == 3) | |
| 267 { | |
| 2 | 268 packet->xmitcsum |= stubhex (ch); |
| 0 | 269 if ((packet->checksum & 255) != packet->xmitcsum) |
| 2 | 270 { |
| 271 putDebugChar ('-'); /* failed checksum */ | |
| 272 packet->state = 0; | |
| 273 return -1; | |
| 274 } | |
| 0 | 275 else |
| 2 | 276 { |
| 277 putDebugChar ('+'); /* successful transfer */ | |
| 278 /* if a sequence char is present, reply the sequence ID */ | |
| 279 if (packet->contents[2] == ':') | |
| 280 { | |
| 281 uint32 count = packet->length; | |
| 282 uint32 i; | |
| 283 putDebugChar (packet->contents[0]); | |
| 284 putDebugChar (packet->contents[1]); | |
| 285 /* remove sequence chars from buffer */ | |
| 286 for (i=3; i <= count; i++) | |
| 287 packet->contents[i-3] = packet->contents[i]; | |
| 288 } | |
| 289 return 1; | |
| 290 } | |
| 0 | 291 } |
| 292 /* We should never get here. */ | |
| 293 packet->state = 0; | |
| 294 return -1; | |
| 295 } | |
| 296 | |
| 297 /* send the packet in buffer. */ | |
| 298 | |
| 2 | 299 void |
| 300 __putpacket (buffer) | |
| 301 char *buffer; | |
| 0 | 302 { |
| 303 unsigned char checksum; | |
| 2 | 304 uint32 count; |
| 0 | 305 unsigned char ch; |
| 306 | |
| 307 /* $<packet info>#<checksum>. */ | |
| 308 do | |
| 309 { | |
| 310 putDebugChar ('$'); | |
| 311 checksum = 0; | |
| 312 count = 0; | |
| 313 | |
| 314 while ((ch = buffer[count])) | |
| 2 | 315 { |
| 316 putDebugChar (ch); | |
| 317 checksum += ch; | |
| 318 count += 1; | |
| 319 } | |
| 0 | 320 |
| 321 putDebugChar ('#'); | |
| 322 putDebugChar (hexchars[(checksum >> 4) & 0xf]); | |
| 323 putDebugChar (hexchars[checksum & 0xf]); | |
| 324 | |
| 325 } | |
| 326 while ((readDebugChar () & 0x7f) != '+'); | |
| 327 } | |
| 328 | |
| 329 static char remcomInBuffer[BUFMAX]; | |
| 330 static char remcomOutBuffer[BUFMAX]; | |
| 331 | |
| 332 /* Indicate to caller of mem2hex or hex2mem that there has been an | |
| 333 error. */ | |
| 334 volatile int __mem_fault = 0; | |
| 335 | |
| 2 | 336 |
| 337 #ifndef TARGET_HAS_OWN_MEM_FUNCS | |
| 338 /* | |
| 339 * _target_readmem_hook / _target_writemem_hook: | |
| 340 * Allow target to get involved in reading/writing memory. | |
| 341 * | |
| 342 * If these hooks are defined by the target, they will be | |
| 343 * called for each user program memory access. Otherwise, the stub | |
| 344 * will simply dereference a pointer to access user program memory. | |
| 345 */ | |
| 346 | |
| 347 unsigned char (*_target_readmem_hook) (unsigned char* addr); | |
| 348 void (*_target_writemem_hook) (unsigned char* addr, | |
| 349 unsigned char value); | |
| 350 | |
| 351 static unsigned char | |
| 352 get_target_byte (volatile unsigned char *address) | |
| 0 | 353 { |
| 2 | 354 if (_target_readmem_hook) /* target needs to control memory access */ |
| 355 return _target_readmem_hook ((unsigned char *) address); | |
| 356 else | |
| 357 return *address; | |
| 358 } | |
| 359 | |
| 360 static void | |
| 361 put_target_byte (volatile unsigned char *address, unsigned char value) | |
| 362 { | |
| 363 if (_target_writemem_hook) /* target needs to control memory access */ | |
| 364 _target_writemem_hook ((unsigned char *) address, value); | |
| 365 else | |
| 366 *address = value; | |
| 367 } | |
| 368 | |
| 369 /* These are the "arguments" to __do_read_mem and __do_write_mem, | |
| 370 which are passed as globals to avoid squeezing them thru | |
| 371 __set_mem_fault_trap. */ | |
| 372 | |
| 373 static volatile target_register_t memCount; | |
| 374 static volatile unsigned char *memSrc, *memDst; | |
| 0 | 375 |
| 2 | 376 /* |
| 377 * __do_read_mem: | |
| 378 * Copy from target memory to trusted memory. | |
| 379 */ | |
| 380 | |
| 381 static void | |
| 382 __do_read_mem (void) | |
| 383 { | |
| 384 __mem_fault = 0; | |
| 385 while (memCount) | |
| 386 { | |
| 387 unsigned char ch = get_target_byte (memSrc++); | |
| 388 | |
| 389 if (__mem_fault) | |
| 390 return; | |
| 391 *memDst++ = ch; | |
| 392 memCount--; | |
| 393 } | |
| 0 | 394 } |
| 395 | |
| 2 | 396 /* |
| 397 * __do_write_mem: | |
| 398 * Copy from trusted memory to target memory. | |
| 399 */ | |
| 400 | |
| 401 static void | |
| 402 __do_write_mem (void) | |
| 403 { | |
| 404 __mem_fault = 0; | |
| 405 while (memCount) | |
| 406 { | |
| 407 unsigned char ch = *memSrc++; | |
| 408 | |
| 409 put_target_byte (memDst++, ch); | |
| 410 if (__mem_fault) | |
| 411 return; | |
| 412 memCount--; | |
| 413 } | |
| 414 } | |
| 415 | |
| 416 /* | |
| 417 * __read_mem_safe: | |
| 418 * Get contents of target memory, abort on error. | |
| 419 */ | |
| 420 | |
| 0 | 421 int |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
422 __read_mem_safe (void *dst, target_register_t src, int count) |
| 0 | 423 { |
| 2 | 424 memCount = count; |
| 425 memSrc = (unsigned char *) src; | |
| 426 memDst = (unsigned char *) dst; | |
| 427 __set_mem_fault_trap (__do_read_mem); | |
| 428 return count - memCount; /* return number of bytes successfully read */ | |
| 0 | 429 } |
| 430 | |
| 2 | 431 /* |
| 432 * __write_mem_safe: | |
| 433 * Set contents of target memory, abort on error. | |
| 434 */ | |
| 435 | |
| 0 | 436 int |
| 437 __write_mem_safe (unsigned char *src, target_register_t dst, int count) | |
| 438 { | |
| 2 | 439 memCount = count; |
| 440 memSrc = (unsigned char *) src; | |
| 441 memDst = (unsigned char *) dst; | |
| 442 __set_mem_fault_trap (__do_write_mem); | |
| 443 return count - memCount; /* return number of bytes successfully read */ | |
| 0 | 444 } |
| 445 | |
| 2 | 446 #endif /* TARGET_HAS_OWN_MEM_FUNCS */ |
| 447 | |
| 448 /* These are the "arguments" to __mem2hex_helper and __hex2mem_helper, | |
| 449 which are passed as globals to avoid squeezing them thru | |
| 450 __set_mem_fault_trap. */ | |
| 451 | |
| 452 static int hexMemCount; | |
| 453 static char *hexMemSrc, *hexMemDst; | |
| 454 static int may_fault_mode; | |
| 455 | |
| 456 /* Hamburger helper? */ | |
| 457 static void | |
| 458 __mem2hex_helper (void) | |
| 459 { | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
460 union { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
461 unsigned long long_val; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
462 unsigned char bytes[sizeof(long)]; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
463 } val; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
464 int len, i; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
465 unsigned char ch; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
466 __mem_fault = 0; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
467 while (hexMemCount > 0) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
468 if (may_fault_mode) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
469 if ((hexMemCount >= sizeof(long)) && |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
470 (((target_register_t)hexMemSrc & (sizeof(long)-1)) == 0)) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
471 // Should be safe to access via a long |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
472 len = sizeof(long); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
473 } else if ((hexMemCount >= sizeof(short)) && |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
474 (((target_register_t)hexMemSrc & (sizeof(short)-1)) == 0)) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
475 // Should be safe to access via a short |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
476 len = sizeof(short); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
477 } else { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
478 len = 1; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
479 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
480 __read_mem_safe(&val.bytes[0], hexMemSrc, len); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
481 } else { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
482 len = 1; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
483 val.bytes[0] = *hexMemSrc; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
484 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
485 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
486 return; |
| 2 | 487 |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
488 for (i = 0; i < len; i++) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
489 ch = val.bytes[i]; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
490 *(hexMemDst++) = hexchars[(ch >> 4) & 0xf]; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
491 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
492 return; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
493 *(hexMemDst++) = hexchars[ch & 0xf]; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
494 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
495 return; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
496 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
497 hexMemCount -= len; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
498 hexMemSrc += len; |
| 2 | 499 } |
| 500 } | |
| 501 | |
| 502 /* Convert the memory pointed to by MEM into HEX, placing result in BUF. | |
| 503 * Return a pointer to the last char put in buf (NUL). In case of a memory | |
| 504 * fault, return 0. | |
| 0 | 505 * If MAY_FAULT is non-zero, then we will handle memory faults by returning |
| 2 | 506 * a 0 (and assume that MEM is a pointer into the user program), else we |
| 507 * treat a fault like any other fault in the stub (and assume that MEM is | |
| 508 * a pointer into the stub's memory). | |
| 0 | 509 */ |
| 510 | |
| 2 | 511 char * |
| 512 __mem2hex (mem, buf, count, may_fault) | |
| 513 char *mem; | |
| 514 char *buf; | |
| 0 | 515 int count; |
| 516 int may_fault; | |
| 517 { | |
| 2 | 518 hexMemDst = (unsigned char *) buf; |
| 519 hexMemSrc = (unsigned char *) mem; | |
| 520 hexMemCount = count; | |
| 521 may_fault_mode = may_fault; | |
| 522 | |
| 523 if (may_fault) | |
| 0 | 524 { |
| 2 | 525 if (__set_mem_fault_trap (__mem2hex_helper)) |
| 526 return 0; | |
| 0 | 527 } |
| 2 | 528 else |
| 529 __mem2hex_helper (); | |
| 0 | 530 |
| 2 | 531 *hexMemDst = 0; |
| 0 | 532 |
| 2 | 533 return (char *) hexMemDst; |
| 0 | 534 } |
| 535 | |
| 2 | 536 static void |
| 537 __hex2mem_helper (void) | |
| 0 | 538 { |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
539 union { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
540 unsigned long long_val; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
541 unsigned char bytes[sizeof(long)]; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
542 } val; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
543 int len, i; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
544 unsigned char ch = '\0'; |
| 0 | 545 |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
546 __mem_fault = 0; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
547 while (hexMemCount > 0 && *hexMemSrc) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
548 if (may_fault_mode) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
549 if ((hexMemCount >= sizeof(long)) && |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
550 (((target_register_t)hexMemDst & (sizeof(long)-1)) == 0)) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
551 len = sizeof(long); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
552 } else if ((hexMemCount >= sizeof(short)) && |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
553 (((target_register_t)hexMemDst & (sizeof(short)-1)) == 0)) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
554 len = sizeof(short); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
555 } else { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
556 len = 1; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
557 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
558 } else { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
559 len = 1; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
560 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
561 |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
562 for (i = 0; i < len; i++) { |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
563 // Check for short data? |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
564 ch = stubhex (*(hexMemSrc++)) << 4; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
565 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
566 return; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
567 ch |= stubhex (*(hexMemSrc++)); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
568 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
569 return; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
570 val.bytes[i] = ch; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
571 } |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
572 |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
573 if (may_fault_mode) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
574 __write_mem_safe (&val.bytes[0], hexMemDst, len); |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
575 else |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
576 *hexMemDst = ch; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
577 |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
578 if (__mem_fault) |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
579 return; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
580 hexMemCount -= len; |
|
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
581 hexMemDst += len; |
| 0 | 582 } |
| 2 | 583 } |
| 584 | |
| 585 /* Convert COUNT bytes of the hex array pointed to by BUF into binary | |
| 586 to be placed in MEM. Return a pointer to the character AFTER the | |
| 587 last byte written. | |
| 588 | |
| 589 If MAY_FAULT is set, we will return a non-zero value if a memory | |
| 590 fault occurs (and we assume that MEM is a pointer into the user | |
| 591 program). Otherwise, we will take a trap just like any other memory | |
| 592 fault (and assume that MEM points into the stub's memory). */ | |
| 0 | 593 |
| 2 | 594 char * |
| 595 __hex2mem (buf, mem, count, may_fault) | |
| 596 char *buf; | |
| 597 char *mem; | |
| 598 int count; | |
| 599 int may_fault; | |
| 600 { | |
| 601 hexMemSrc = (unsigned char *) buf; | |
| 602 hexMemDst = (unsigned char *) mem; | |
| 603 hexMemCount = count; | |
| 604 may_fault_mode = may_fault; | |
| 0 | 605 |
| 2 | 606 if (may_fault) |
| 607 { | |
| 608 if (__set_mem_fault_trap (__hex2mem_helper)) | |
| 609 return 0; | |
| 610 } | |
| 611 else | |
| 612 __hex2mem_helper (); | |
| 613 | |
| 614 return (char *) hexMemDst; | |
| 615 } | |
| 616 | |
| 617 void | |
| 618 set_debug_traps (void) | |
| 619 { | |
| 620 __install_traps (); | |
| 621 initialized = 1; /* FIXME: Change this to dbg_stub_initialized */ | |
| 0 | 622 } |
| 623 | |
| 624 /* | |
| 625 * While we find nice hex chars, build an int. | |
| 626 * Return number of chars processed. | |
| 627 */ | |
| 628 | |
| 2 | 629 unsigned int |
| 630 __hexToInt (char **ptr, target_register_t *intValue) | |
| 0 | 631 { |
| 632 int numChars = 0; | |
| 633 int hexValue; | |
| 634 | |
| 635 *intValue = 0; | |
| 636 | |
| 637 while (**ptr) | |
| 638 { | |
| 2 | 639 hexValue = stubhex (**ptr); |
| 0 | 640 if (hexValue < 0) |
| 2 | 641 break; |
| 0 | 642 |
| 643 *intValue = (*intValue << 4) | hexValue; | |
| 644 numChars ++; | |
| 645 | |
| 646 (*ptr)++; | |
| 647 } | |
| 648 | |
| 649 return (numChars); | |
| 650 } | |
| 651 | |
| 652 /* | |
| 653 * Complement of __hexToInt: take an int of size "numBits", | |
| 654 * convert it to a hex string. Return length of (unterminated) output. | |
| 655 */ | |
| 656 | |
| 657 unsigned int | |
| 658 __intToHex (char *ptr, target_register_t intValue, int numBits) | |
| 659 { | |
| 660 int numChars = 0; | |
| 661 | |
| 662 if (intValue == 0) | |
| 663 { | |
| 664 *(ptr++) = '0'; | |
| 665 *(ptr++) = '0'; | |
| 666 return 2; | |
| 667 } | |
| 668 | |
| 669 numBits = (numBits + 7) / 8; | |
| 670 while (numBits) | |
| 671 { | |
| 672 int v = (intValue >> ((numBits - 1) * 8)); | |
| 673 if (v || (numBits == 1)) | |
| 2 | 674 { |
| 675 v = v & 255; | |
| 676 *(ptr++) = __tohex ((v / 16) & 15); | |
| 677 *(ptr++) = __tohex (v & 15); | |
| 678 numChars += 2; | |
| 679 } | |
| 0 | 680 numBits--; |
| 681 } | |
| 682 | |
| 683 return (numChars); | |
| 684 } | |
| 685 | |
| 2 | 686 #if DEBUG_THREADS |
| 687 /* | |
| 688 * Kernel Thread Control | |
| 689 * | |
| 690 * If the current thread is set to other than zero (or minus one), | |
| 691 * then ask the kernel to lock it's scheduler so that only that thread | |
| 692 * can run. | |
| 693 */ | |
| 694 | |
| 695 static unsigned char did_lock_scheduler = 0; | |
| 696 static unsigned char did_disable_interrupts = 0; | |
| 697 | |
| 698 /* Pointer to "kernel call" for scheduler control */ | |
| 699 static int (*schedlock_fn) (int, int, long) = stub_lock_scheduler; | |
| 700 | |
| 701 /* Pointer to target stub call for disabling interrupts. | |
| 702 Target stub will initialize this if it can. */ | |
| 703 int (*__disable_interrupts_hook) (int); /* don't initialize here! */ | |
| 704 #endif | |
| 705 | |
| 706 static void | |
| 707 lock_thread_scheduler (int kind) /* "step" or "continue" */ | |
| 708 { | |
| 709 #if DEBUG_THREADS | |
| 710 int ret = 0; | |
| 711 | |
| 712 /* GDB will signal its desire to run a single thread | |
| 713 by setting _gdb_cont_thread to non-zero / non-negative. */ | |
| 714 if (_gdb_cont_thread <= 0) | |
| 715 return; | |
| 716 | |
| 717 if (schedlock_fn) /* kernel call */ | |
| 718 ret = (*schedlock_fn) (1, kind, _gdb_cont_thread); | |
| 719 | |
| 720 if (ret == 1) | |
| 721 { | |
| 722 did_lock_scheduler = 1; | |
| 723 return; | |
| 724 } | |
| 725 | |
| 726 if (schedlock_fn == 0 || /* no kernel scheduler call */ | |
| 727 ret == -1) /* kernel asks stub to handle it */ | |
| 728 if (__disable_interrupts_hook) /* target stub has capability */ | |
| 729 if ((*__disable_interrupts_hook) (1)) | |
| 730 { | |
| 731 did_disable_interrupts = 1; | |
| 732 return; | |
| 733 } | |
| 734 #endif /* DEBUG_THREADS */ | |
| 735 } | |
| 736 | |
| 737 static void | |
| 738 unlock_thread_scheduler () | |
| 739 { | |
| 740 #if DEBUG_THREADS | |
| 741 if (did_lock_scheduler) | |
| 742 if (schedlock_fn) /* kernel call */ | |
| 743 { | |
| 744 (*schedlock_fn) (0, 0, _gdb_cont_thread); | |
| 745 /* I could check the return value, but | |
| 746 what would I do if it failed??? */ | |
| 747 did_lock_scheduler = 0; | |
| 748 } | |
| 749 if (did_disable_interrupts) | |
| 750 if (__disable_interrupts_hook) /* target stub call */ | |
| 751 { | |
| 752 (*__disable_interrupts_hook) (0); | |
| 753 /* Again, I could check the return value, but | |
| 754 what would I do if it failed??? */ | |
| 755 did_disable_interrupts = 0; | |
| 756 } | |
| 757 #endif /* DEBUG_THREADS */ | |
| 758 } | |
| 759 | |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
760 #ifdef CYGPKG_CYGMON |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
761 int processing_breakpoint_function = 0; |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
762 #endif |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
763 |
| 0 | 764 void |
| 765 __handle_exception (void) | |
| 766 { | |
| 767 int sigval; | |
| 768 | |
| 2 | 769 #ifdef TARGET_HAS_NEXT_STEP |
| 770 if (! __next_step_done ()) | |
| 771 { | |
| 772 __clear_breakpoints (); | |
| 773 __install_breakpoints (); | |
| 774 __single_step (); | |
| 775 return; | |
| 776 } | |
| 777 #endif | |
| 0 | 778 |
| 2 | 779 #ifdef __ECOS__ |
| 780 // We need to unpack the registers before they are accessed. | |
| 781 if (__cleanup_vec != NULL) | |
| 782 __cleanup_vec (); | |
| 0 | 783 |
|
136
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
784 #if defined(CYGSEM_REDBOOT_BSP_SYSCALLS) |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
785 // Temporary support for gnupro bsp SWIs |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
786 if (__is_bsp_syscall()) |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
787 { |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
788 if (hal_syscall_handler() == 0) |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
789 { |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
790 if (__init_vec != NULL) |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
791 __init_vec (); |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
792 return; |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
793 } |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
794 } |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
795 #endif |
|
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
796 |
| 2 | 797 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT |
| 798 // Special case for GDB BREAKs. This flag is set by cyg_stub_cleanup. | |
| 799 if (cyg_hal_gdb_break) { | |
| 800 cyg_hal_gdb_break = 0; | |
| 801 sigval = SIGINT; | |
| 802 } else | |
| 803 #endif | |
| 804 sigval = __computeSignal (__get_trap_number ()); | |
|
136
a9ac27ec7abc
Merge from eCos master repository on 2000-11-17-18:24:25-GMT
jlarmour
parents:
132
diff
changeset
|
805 |
| 2 | 806 #else // __ECOS__ |
| 0 | 807 /* reply to host that an exception has occurred */ |
| 808 sigval = __computeSignal (__get_trap_number ()); | |
| 2 | 809 #endif // __ECOS__ |
| 0 | 810 |
| 811 if (__is_breakpoint_function ()) | |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
812 { |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
813 #ifdef CYGPKG_CYGMON |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
814 processing_breakpoint_function = 1; |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
815 #endif |
| 0 | 816 __skipinst (); |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
817 } else { |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
818 #ifdef CYGPKG_CYGMON |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
819 processing_breakpoint_function = 0; |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
820 #endif |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
821 } |
| 0 | 822 |
| 2 | 823 #ifndef __ECOS__ |
| 824 if (__cleanup_vec != NULL) | |
| 825 __cleanup_vec (); | |
| 826 #endif // !__ECOS__ | |
| 827 | |
| 828 __clear_breakpoints (); | |
| 829 | |
| 830 /* Undo effect of previous single step. */ | |
| 831 unlock_thread_scheduler (); | |
| 832 __clear_single_step (); | |
| 833 | |
|
48
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
834 #ifdef __ECOS__ |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
835 /* Need to flush the data and instruction cache here, as we may have |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
836 removed a breakpoint in __single_step - and we may be sharing |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
837 some code with the application! */ |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
838 |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
839 __data_cache (CACHE_FLUSH) ; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
840 __instruction_cache (CACHE_FLUSH) ; |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
841 #endif |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
842 |
| 2 | 843 #ifdef SIGSYSCALL |
| 844 if (sigval == SIGSYSCALL) | |
| 0 | 845 { |
| 846 int val; | |
| 847 /* Do the skipinst FIRST. */ | |
| 2 | 848 #ifndef SYSCALL_PC_AFTER_INST |
| 0 | 849 __skipinst (); |
| 2 | 850 #endif |
| 0 | 851 val = __process_syscall_vec (__get_syscall_num ()); |
| 2 | 852 if (val < 0) |
| 853 sigval = -val; | |
| 854 else | |
| 855 sigval = 0; | |
| 0 | 856 } |
| 857 | |
| 858 #endif | |
| 859 | |
| 2 | 860 /* Indirect function call to stub, cygmon monitor or other */ |
| 861 if (sigval != 0) | |
| 862 { | |
| 863 while (__process_exception_vec (sigval)) | |
| 864 { | |
| 865 /* Empty! */ | |
| 866 } | |
| 867 } | |
| 0 | 868 |
| 2 | 869 __install_breakpoints (); |
| 0 | 870 |
| 2 | 871 if (__init_vec != NULL) |
| 872 __init_vec (); | |
| 0 | 873 } |
| 874 | |
| 2 | 875 /* |
| 876 * _get_trace_register_hook: | |
| 877 * This function pointer will be non-zero if the trace component | |
| 878 * wants to intercept requests for register values. | |
| 879 * | |
| 880 * FIXME: evidently I need a new hook for large registers... | |
| 881 */ | |
| 882 | |
| 883 int (*_get_trace_register_hook) (regnames_t, target_register_t *); | |
| 884 | |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
885 void |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
886 stub_format_registers(char *ptr) |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
887 { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
888 int regnum; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
889 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
890 for (regnum = 0; regnum < NUMREGS_GDB; regnum++) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
891 /* We need to compensate for the value offset within the |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
892 register. */ |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
893 char dummyDat[32]; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
894 target_register_t addr; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
895 char *vptr; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
896 int reg_valid = 1; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
897 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
898 #ifdef TARGET_HAS_LARGE_REGISTERS |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
899 if (sizeof (target_register_t) < REGSIZE (regnum)) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
900 get_register_as_bytes (regnum, dummyDat); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
901 vptr = dummyDat; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
902 } else |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
903 #endif |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
904 { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
905 if (_get_trace_register_hook) |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
906 reg_valid = _get_trace_register_hook (regnum, &addr); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
907 else |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
908 { |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
909 addr = get_register (regnum); |
|
115
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
910 #ifdef CYGHWR_REGISTER_VALIDITY_CHECKING |
|
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
911 reg_valid = get_register_valid (regnum); |
|
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
912 #endif |
|
6ed91473a1cd
Merge from eCos master repository on 2000-08-21-22:40:54-BST
jlarmour
parents:
112
diff
changeset
|
913 } |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
914 vptr = ((char *) &addr); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
915 if (sizeof (addr) > REGSIZE(regnum)) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
916 /* May need to cope with endian-ness */ |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
917 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
918 #if !defined(__LITTLE_ENDIAN__) && !defined(_LITTLE_ENDIAN) |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
919 vptr += sizeof (addr) - REGSIZE (regnum); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
920 #endif |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
921 } else if (sizeof (addr) < REGSIZE (regnum)) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
922 int off = REGSIZE (regnum) - sizeof (addr); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
923 int x; |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
924 char extend_val = 0; |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
925 |
|
121
6bd9d475ed4b
Merge from eCos master repository on 2000-09-04-20:50:20-BST
jlarmour
parents:
115
diff
changeset
|
926 #ifdef CYGARC_SIGN_EXTEND_REGISTERS |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
927 { |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
928 unsigned long bits_in_addr = (sizeof(addr) << 3); // ie Size in bytes * 8 |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
929 target_register_t sign_bit_mask = (1 << (bits_in_addr - 1)); |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
930 if ((addr & sign_bit_mask) == sign_bit_mask) |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
931 extend_val = ~0; |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
932 } |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
933 #endif |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
934 |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
935 #if defined(__LITTLE_ENDIAN__) || defined(_LITTLE_ENDIAN) |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
936 for (x = 0; x < off; x++) |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
937 dummyDat[x + sizeof(addr)] = extend_val; |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
938 memcpy (dummyDat, &addr, sizeof (addr)); |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
939 #else |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
940 for (x = 0; x < off; x++) |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
941 dummyDat[x] = extend_val; |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
942 memcpy (dummyDat + off, &addr, sizeof (addr)); |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
943 #endif |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
944 vptr = dummyDat; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
945 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
946 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
947 if (reg_valid) { /* we have a valid reg value */ |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
948 ptr = __mem2hex (vptr, ptr, REGSIZE (regnum), 0); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
949 } else { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
950 /* Trace component returned a failure code. |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
951 This means that the register value is not available. |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
952 We'll fill it with 'x's, and GDB will understand. */ |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
953 memset (ptr, 'x', 2 * REGSIZE (regnum)); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
954 ptr += 2 * REGSIZE (regnum); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
955 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
956 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
957 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
958 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
959 void |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
960 stub_update_registers(char *in_ptr, char *out_ptr) |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
961 { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
962 char *ptr = &in_ptr[1]; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
963 int x; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
964 int sr = 0, er = NUMREGS_GDB; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
965 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
966 if (*in_ptr == 'P') { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
967 target_register_t regno; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
968 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
969 if (__hexToInt (&ptr, ®no) && (*ptr++ == '=')) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
970 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
971 sr = regno; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
972 er = regno + 1; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
973 } else { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
974 strcpy (out_ptr, "P01"); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
975 return; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
976 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
977 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
978 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
979 for (x = sr; x < er; x++) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
980 target_register_t value = 0; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
981 char *vptr; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
982 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
983 #ifdef TARGET_HAS_LARGE_REGISTERS |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
984 if (sizeof (target_register_t) < REGSIZE (x)) { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
985 char dummyDat [32]; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
986 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
987 __hex2mem (ptr, dummyDat, REGSIZE (x), 0); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
988 put_register_as_bytes (x, dummyDat); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
989 } else |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
990 #endif |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
991 { |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
992 vptr = ((char *) &value); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
993 #if !defined(__LITTLE_ENDIAN__) && !defined(_LITTLE_ENDIAN) |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
994 vptr += sizeof (value) - REGSIZE (x); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
995 #endif |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
996 __hex2mem (ptr, vptr, REGSIZE (x), 0); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
997 put_register (x, value); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
998 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
999 ptr += REGSIZE (x) * 2; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1000 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1001 |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1002 strcpy (out_ptr, "OK"); |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1003 } |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1004 |
| 2 | 1005 int |
| 1006 __process_packet (char *packet) | |
| 0 | 1007 { |
| 2 | 1008 int is_binary = 0; |
|
132
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1009 #if defined(CYGNUM_HAL_BREAKPOINT_LIST_SIZE) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1010 int is_Z = 0; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1011 #endif |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1012 |
| 0 | 1013 remcomOutBuffer[0] = 0; |
| 1014 switch (packet[0]) | |
| 1015 { | |
| 1016 case '?': | |
| 1017 { | |
| 2 | 1018 int sigval = __computeSignal (__get_trap_number ()); |
| 1019 remcomOutBuffer[0] = 'S'; | |
| 1020 remcomOutBuffer[1] = hexchars[(sigval >> 4) & 0xf]; | |
| 1021 remcomOutBuffer[2] = hexchars[sigval & 0xf]; | |
| 1022 remcomOutBuffer[3] = 0; | |
| 1023 break; | |
| 0 | 1024 } |
| 1025 | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
34
diff
changeset
|
1026 #ifdef __ECOS__ |
|
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
34
diff
changeset
|
1027 #if !defined(CYG_HAL_STARTUP_RAM) // Only for ROM based stubs |
|
132
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1028 #if 0 // Disable to avoid conflict with stub-breakpoint z/Z-packets |
|
78
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1029 case 'z': |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1030 /* report IO buffer sizes so download can achieve optimal |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1031 download speed */ |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1032 { |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1033 int i; |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1034 i = __intToHex (remcomOutBuffer, BUFMAX, 32); |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1035 remcomOutBuffer[i] = 0; |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1036 break; |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1037 } |
|
132
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1038 #endif |
|
78
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1039 case 'd': |
|
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1040 /* toggle debug flag */ |
|
130
eb9fd8c04db3
Merge from eCos master repository on 2000-10-23-17:01:37-BST
jlarmour
parents:
121
diff
changeset
|
1041 strcpy(remcomOutBuffer, "eCos GDB stubs" |
|
eb9fd8c04db3
Merge from eCos master repository on 2000-10-23-17:01:37-BST
jlarmour
parents:
121
diff
changeset
|
1042 #ifdef CYGPKG_REDBOOT |
|
eb9fd8c04db3
Merge from eCos master repository on 2000-10-23-17:01:37-BST
jlarmour
parents:
121
diff
changeset
|
1043 " [with RedBoot]" |
|
eb9fd8c04db3
Merge from eCos master repository on 2000-10-23-17:01:37-BST
jlarmour
parents:
121
diff
changeset
|
1044 #endif |
|
eb9fd8c04db3
Merge from eCos master repository on 2000-10-23-17:01:37-BST
jlarmour
parents:
121
diff
changeset
|
1045 " - built " __DATE__ " / " __TIME__); |
|
78
59d97b6ba612
Merge from eCos master repository on 2000-03-28-19:50:47-BST
jlarmour
parents:
64
diff
changeset
|
1046 break; |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
34
diff
changeset
|
1047 #endif |
|
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
34
diff
changeset
|
1048 #endif // __ECOS__ |
| 0 | 1049 |
| 1050 case 'q': | |
| 1051 /* general query packet */ | |
| 1052 process_query (&packet[1]); | |
| 1053 break; | |
| 1054 | |
| 1055 case 'Q': | |
| 1056 /* general set packet */ | |
| 1057 process_set (&packet[1]); | |
| 1058 break; | |
| 1059 | |
| 2 | 1060 case 'g': /* return the value of the CPU registers */ |
| 0 | 1061 { |
| 2 | 1062 char *ptr = remcomOutBuffer; |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1063 stub_format_registers(ptr); |
| 2 | 1064 break; |
| 1065 } | |
| 0 | 1066 |
| 2 | 1067 case 'A': /* set program arguments */ |
| 1068 { | |
| 1069 if (packet[1] == '\0') | |
| 1070 { | |
| 1071 __free_program_args (); | |
| 1072 strcpy (remcomOutBuffer, "OK"); | |
| 1073 } | |
| 1074 else | |
| 1075 { | |
| 1076 target_register_t arglen, argnum; | |
| 1077 char *ptr = &packet[1]; | |
| 1078 | |
| 1079 while (1) | |
| 1080 { | |
| 1081 if (__hexToInt (&ptr, &arglen) | |
| 1082 && (*ptr++ == ',') | |
| 1083 && __hexToInt (&ptr, &argnum) | |
| 1084 && (*ptr++ == ',')) | |
| 1085 { | |
| 1086 if (arglen > 0) | |
| 1087 { | |
| 1088 char *s = __add_program_arg (argnum, arglen); | |
| 1089 if (s != NULL) | |
| 1090 { | |
| 1091 __hex2mem (ptr, s, arglen, 0); | |
| 1092 } | |
| 1093 ptr += arglen * 2; | |
| 1094 } | |
| 1095 | |
| 1096 if (*ptr == ',') | |
| 1097 ptr++; | |
| 1098 else | |
| 1099 break; | |
| 1100 } | |
| 1101 else | |
| 1102 break; | |
| 1103 } | |
| 1104 if (*ptr == '\0') | |
| 1105 strcpy (remcomOutBuffer, "OK"); | |
| 1106 else | |
| 1107 strcpy (remcomOutBuffer, "E01"); | |
| 1108 } | |
| 0 | 1109 } |
| 2 | 1110 break; |
| 0 | 1111 |
| 1112 case 'P': | |
| 2 | 1113 case 'G': /* set the value of the CPU registers - return OK */ |
| 0 | 1114 { |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1115 char *in_ptr = &packet[0]; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1116 char *out_ptr = remcomOutBuffer; |
|
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
1117 stub_update_registers(in_ptr, out_ptr); |
| 2 | 1118 break; |
| 0 | 1119 } |
| 1120 | |
| 2 | 1121 case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ |
| 0 | 1122 /* Try to read %x,%x. */ |
| 1123 { | |
| 2 | 1124 target_register_t addr, length; |
| 1125 char *ptr = &packet[1]; | |
| 0 | 1126 |
| 2 | 1127 if (__hexToInt (&ptr, &addr) |
| 1128 && *ptr++ == ',' | |
| 1129 && __hexToInt (&ptr, &length)) | |
| 1130 { | |
| 1131 if (__mem2hex ((char *) addr, remcomOutBuffer, length, 1)) | |
| 1132 break; | |
| 0 | 1133 |
| 2 | 1134 strcpy (remcomOutBuffer, "E03"); |
| 1135 } | |
| 1136 else | |
| 1137 strcpy (remcomOutBuffer, "E01"); | |
| 1138 break; | |
| 0 | 1139 } |
| 1140 | |
| 2 | 1141 case 'X': |
| 1142 /* XAA..AA,LLLL: Write LLLL escaped binary bytes at address AA.AA */ | |
| 1143 is_binary = 1; | |
| 1144 /* fall through */ | |
| 0 | 1145 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ |
| 1146 /* Try to read '%x,%x:'. */ | |
| 1147 { | |
| 2 | 1148 target_register_t addr, length; |
| 1149 char *ptr = &packet[1], buf[128]; | |
| 1150 int i; | |
| 1151 | |
| 1152 if (__hexToInt (&ptr, &addr) | |
| 1153 && *ptr++ == ',' | |
| 1154 && __hexToInt (&ptr, &length) | |
| 1155 && *ptr++ == ':') | |
| 1156 { | |
| 1157 if (is_binary) | |
| 1158 { | |
| 1159 while (length > 0) | |
| 1160 { | |
| 1161 for (i = 0; i < sizeof(buf) && i < length; i++) | |
| 1162 if ((buf[i] = *ptr++) == 0x7d) | |
| 1163 buf[i] = 0x20 | (*ptr++ & 0xff); | |
| 1164 | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1165 if (__write_mem_safe (buf, (void *)addr, i) != i) |
| 2 | 1166 break; |
| 0 | 1167 |
| 2 | 1168 length -= i; |
| 1169 addr += i; | |
| 1170 } | |
| 1171 if (length <= 0) | |
| 1172 strcpy (remcomOutBuffer, "OK"); | |
| 1173 else | |
| 1174 strcpy (remcomOutBuffer, "E03"); | |
| 1175 } | |
| 1176 else | |
| 1177 { | |
| 1178 if (__hex2mem (ptr, (char *) addr, length, 1) != NULL) | |
| 1179 strcpy (remcomOutBuffer, "OK"); | |
| 1180 else | |
| 1181 strcpy (remcomOutBuffer, "E03"); | |
| 1182 } | |
| 1183 } | |
| 1184 else | |
| 1185 strcpy (remcomOutBuffer, "E02"); | |
| 1186 break; | |
| 0 | 1187 } |
| 1188 | |
| 1189 case 'S': | |
| 2 | 1190 case 's': /* sAA..AA Step from address AA..AA (optional) */ |
| 0 | 1191 case 'C': |
| 2 | 1192 case 'c': /* cAA..AA Continue at address AA..AA (optional) */ |
| 0 | 1193 /* try to read optional parameter, pc unchanged if no parm */ |
| 1194 | |
| 1195 { | |
| 2 | 1196 char *ptr = &packet[1]; |
| 1197 target_register_t addr; | |
| 1198 target_register_t sigval = 0; | |
| 1199 | |
| 1200 if (packet[0] == 'C' || packet[0] == 'S') | |
| 1201 { | |
| 1202 __hexToInt (&ptr, &sigval); | |
| 1203 if (*ptr == ';') | |
| 1204 ptr++; | |
| 1205 } | |
| 0 | 1206 |
| 2 | 1207 if (__hexToInt (&ptr, &addr)) |
| 1208 set_pc (addr); | |
| 1209 | |
| 1210 /* Need to flush the instruction cache here, as we may have | |
| 1211 deposited a breakpoint, and the icache probably has no way of | |
| 1212 knowing that a data ref to some location may have changed | |
| 1213 something that is in the instruction cache. */ | |
| 1214 | |
| 1215 #ifdef __ECOS__ | |
| 1216 __data_cache (CACHE_FLUSH) ; | |
| 1217 #endif | |
| 1218 __instruction_cache (CACHE_FLUSH) ; | |
| 0 | 1219 |
| 2 | 1220 /* If we have a function to handle signals, call it. */ |
| 1221 if (sigval != 0 && __process_signal_vec != NULL) | |
| 1222 { | |
| 1223 /* If 0 is returned, we either ignored the signal or invoked a user | |
| 1224 handler. Otherwise, the user program should die. */ | |
| 1225 if (! __process_signal_vec (sigval)) | |
| 1226 sigval = 0; | |
| 1227 } | |
| 0 | 1228 |
| 2 | 1229 if (sigval != 0) |
| 1230 { | |
| 1231 sigval = SIGKILL; /* Always nuke the program */ | |
| 1232 __kill_program (sigval); | |
| 1233 return 0; | |
| 1234 } | |
| 0 | 1235 |
|
48
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1236 #ifdef __ECOS__ |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1237 // CASE 102327 - watchpoints fight with output, so do not step |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1238 // through $O packet output routines. |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1239 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1240 if ( cyg_hal_gdb_break_is_set() ) { |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1241 packet[0] = 'c'; // Force it to be a "continue" instead of step. |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1242 cyg_hal_gdb_running_step = 1; // And tell the hal_stub... |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1243 } |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1244 #endif |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1245 #endif |
|
1370c5e55234
Merge from eCos master repository on 1999-10-25-21:18:27-BST
jlarmour
parents:
46
diff
changeset
|
1246 |
| 2 | 1247 /* Set machine state to force a single step. */ |
| 1248 if (packet[0] == 's' || packet[0] == 'S') | |
| 1249 { | |
| 1250 lock_thread_scheduler (0); /* 0 == single-step */ | |
| 1251 #ifdef __ECOS__ | |
| 1252 // PR 19845 workaround: | |
| 1253 // Make sure the single-step magic affects the correct registers. | |
| 1254 _registers = ®isters[0]; | |
| 1255 #endif | |
| 1256 __single_step (); | |
| 1257 } | |
| 1258 else | |
| 1259 { | |
| 1260 lock_thread_scheduler (1); /* 1 == continue */ | |
| 1261 } | |
| 0 | 1262 |
|
28
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1263 #ifdef __ECOS__ |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1264 /* Need to flush the data and instruction cache here, as we may have |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1265 deposited a breakpoint in __single_step. */ |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1266 |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1267 __data_cache (CACHE_FLUSH) ; |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1268 __instruction_cache (CACHE_FLUSH) ; |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1269 #endif |
|
18ee5a9c102e
Merge from eCos master repository on 1999-08-09-17:04:48-BST
jlarmour
parents:
2
diff
changeset
|
1270 |
| 2 | 1271 return -1; |
| 0 | 1272 } |
| 1273 | |
| 1274 /* kill the program */ | |
| 1275 case 'k' : | |
| 1276 __process_exit_vec (); | |
| 1277 return 1; | |
| 2 | 1278 |
| 1279 case 'r': /* Reset */ | |
| 0 | 1280 __reset (); |
| 1281 break; | |
| 2 | 1282 |
| 0 | 1283 case 'H': |
| 1284 STUB_PKT_CHANGETHREAD (packet+1, remcomOutBuffer, 300) ; | |
| 1285 break ; | |
| 1286 case 'T' : | |
| 1287 STUB_PKT_THREAD_ALIVE (packet+1, remcomOutBuffer, 300) ; | |
| 1288 break ; | |
| 2 | 1289 case 'B': |
| 1290 /* breakpoint */ | |
| 0 | 1291 { |
| 2 | 1292 target_register_t addr; |
| 1293 char mode; | |
| 1294 char *ptr = &packet[1]; | |
| 1295 if (__hexToInt (&ptr, &addr) && *(ptr++) == ',') | |
| 1296 { | |
| 1297 mode = *(ptr++); | |
| 1298 if (mode == 'C') | |
| 1299 __remove_breakpoint (addr); | |
| 1300 else | |
| 1301 __set_breakpoint (addr); | |
| 1302 strcpy (remcomOutBuffer, "OK"); | |
| 1303 } | |
| 1304 else | |
| 1305 { | |
| 1306 strcpy (remcomOutBuffer, "E01"); | |
| 1307 } | |
| 1308 break; | |
| 1309 } | |
| 0 | 1310 |
| 2 | 1311 case 'b': /* bBB... Set baud rate to BB... */ |
| 1312 { | |
| 1313 target_register_t baudrate; | |
| 0 | 1314 |
| 2 | 1315 char *ptr = &packet[1]; |
| 1316 if (!__hexToInt (&ptr, &baudrate)) | |
| 1317 { | |
| 1318 strcpy (remcomOutBuffer, "B01"); | |
| 1319 break; | |
| 1320 } | |
| 1321 | |
| 1322 __putpacket ("OK"); /* Ack before changing speed */ | |
| 1323 __set_baud_rate (baudrate); | |
| 1324 break; | |
| 0 | 1325 } |
|
132
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1326 |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1327 #if defined(CYGNUM_HAL_BREAKPOINT_LIST_SIZE) && (CYGNUM_HAL_BREAKPOINT_LIST_SIZE > 0) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1328 case 'Z': |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1329 is_Z = 1; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1330 case 'z': |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1331 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1332 char *ptr = &packet[1]; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1333 target_register_t ztype, addr, length; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1334 int err; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1335 |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1336 if (__hexToInt (&ptr, &ztype) && *(ptr++) == ',') |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1337 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1338 if (__hexToInt (&ptr, &addr)) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1339 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1340 if (*(ptr++) == ',') |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1341 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1342 /* When there is a comma, there must be a length */ |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1343 if (!__hexToInt (&ptr, &length)) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1344 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1345 strcpy (remcomOutBuffer, "E02"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1346 break; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1347 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1348 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1349 else |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1350 length = 0; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1351 |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1352 switch (ztype) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1353 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1354 case 0: |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1355 /* sw breakpoint */ |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1356 if (is_Z) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1357 err = __set_breakpoint(addr); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1358 else |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1359 err = __remove_breakpoint(addr); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1360 if (!err) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1361 strcpy (remcomOutBuffer, "OK"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1362 else |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1363 strcpy (remcomOutBuffer, "E02"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1364 break; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1365 #ifdef HAL_STUB_HW_BREAKPOINT |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1366 case 1: |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1367 /* hw breakpoint */ |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1368 if (!HAL_STUB_HW_BREAKPOINT(is_Z, (void *)addr, length)) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1369 strcpy (remcomOutBuffer, "OK"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1370 else |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1371 strcpy (remcomOutBuffer, "E02"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1372 break; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1373 #endif |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1374 #ifdef HAL_STUB_HW_WATCHPOINT |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1375 case 2: |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1376 case 3: |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1377 case 4: |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1378 { |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1379 /* hw watchpoint */ |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1380 if (!HAL_STUB_HW_WATCHPOINT(is_Z, (void *)addr, length, ztype)) |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1381 strcpy (remcomOutBuffer, "OK"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1382 else |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1383 strcpy (remcomOutBuffer, "E02"); |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1384 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1385 break; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1386 #endif |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1387 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1388 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1389 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1390 break; |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1391 } |
|
0ae0bc38e387
Merge from eCos master repository on 2000-10-31-00:30:36-GMT
jlarmour
parents:
130
diff
changeset
|
1392 #endif // Z packet support |
| 2 | 1393 default: |
| 1394 __process_target_packet (packet, remcomOutBuffer, 300); | |
| 1395 break; | |
| 0 | 1396 } |
| 1397 | |
| 1398 /* reply to the request */ | |
| 2 | 1399 __putpacket (remcomOutBuffer); |
| 0 | 1400 return 0; |
| 1401 } | |
| 1402 | |
| 1403 static void | |
| 1404 send_t_packet (int sigval) | |
| 1405 { | |
| 1406 __build_t_packet (sigval, remcomOutBuffer); | |
| 2 | 1407 __putpacket (remcomOutBuffer); |
| 0 | 1408 } |
| 1409 | |
| 1410 /* | |
| 1411 * This function does all command procesing for interfacing to gdb. | |
| 1412 */ | |
| 1413 | |
| 1414 static int | |
| 1415 process_exception (int sigval) | |
| 1416 { | |
| 1417 int status; | |
| 1418 | |
| 1419 /* Nasty. */ | |
| 1420 if (ungot_char < 0) | |
| 1421 send_t_packet (sigval); | |
| 1422 | |
| 1423 do { | |
| 1424 getpacket (remcomInBuffer); | |
| 2 | 1425 status = __process_packet (remcomInBuffer); |
| 0 | 1426 } while (status == 0); |
| 1427 | |
| 1428 if (status < 0) | |
| 1429 return 0; | |
| 1430 else | |
| 1431 return 1; | |
| 1432 } | |
| 1433 | |
| 1434 void | |
| 1435 __send_exit_status (int status) | |
| 1436 { | |
| 1437 remcomOutBuffer[0] = 'W'; | |
| 1438 remcomOutBuffer[1] = hexchars[(status >> 4) & 0xf]; | |
| 1439 remcomOutBuffer[2] = hexchars[status & 0xf]; | |
| 1440 remcomOutBuffer[3] = 0; | |
| 2 | 1441 __putpacket (remcomOutBuffer); |
| 0 | 1442 } |
| 1443 | |
| 2 | 1444 /* Read up to MAXLEN bytes from the remote GDB client, and store in DEST |
| 1445 (which is a pointer in the user program). BLOCK indicates what mode | |
| 1446 is being used; if it is set, we will wait for MAXLEN bytes to be | |
| 1447 entered. Otherwise, the function will return immediately with whatever | |
| 1448 bytes are waiting to be read. | |
| 1449 | |
| 1450 The value returned is the number of bytes read. A -1 indicates that an | |
| 1451 error of some sort occurred. */ | |
| 1452 | |
| 0 | 1453 int |
| 2 | 1454 __get_gdb_input (target_register_t dest, int maxlen, int block) |
| 0 | 1455 { |
| 1456 char buf[4]; | |
| 1457 int len, i; | |
| 2 | 1458 char d; |
| 0 | 1459 |
| 1460 buf[0] = 'I'; | |
| 1461 buf[1] = '0'; | |
| 1462 buf[2] = block ? '0' : '1'; | |
| 1463 buf[3] = 0; | |
| 2 | 1464 __putpacket (buf); |
| 0 | 1465 getpacket (remcomInBuffer); |
| 1466 if (remcomInBuffer[0] != 'I') | |
| 1467 return -1; | |
| 1468 len = stubhex (remcomInBuffer[1]) * 16 + stubhex (remcomInBuffer[2]); | |
| 1469 for (i = 0; i < len; i++) | |
| 1470 { | |
| 2 | 1471 d = stubhex (remcomInBuffer[3 + i * 2]) * 16; |
| 1472 d |= stubhex (remcomInBuffer[3 + i * 2 + 1]); | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1473 __write_mem_safe (&d, (void *)(dest + i), 1); |
| 0 | 1474 } |
| 2 | 1475 /* Write the trailing \0. */ |
| 1476 d = '\0'; | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1477 __write_mem_safe (&d, (void *)(dest + i), 1); |
| 0 | 1478 return len; |
| 1479 } | |
| 1480 | |
| 1481 void | |
| 1482 __output_hex_value (target_register_t i) | |
| 1483 { | |
| 1484 char buf[32], *ptr=buf+31; | |
| 1485 unsigned int x; | |
| 1486 | |
| 1487 *ptr = 0; | |
| 2 | 1488 for (x = 0; x < (sizeof (i) * 2); x++) |
| 0 | 1489 { |
| 1490 *(--ptr) = hexchars[i & 15]; | |
| 1491 i = i >> 4; | |
| 1492 } | |
| 1493 while (*ptr) | |
| 1494 { | |
| 1495 putDebugChar (*(ptr++)); | |
| 1496 } | |
| 1497 } | |
| 1498 | |
| 2 | 1499 /* Write the C-style string pointed to by STR to the GDB comm port. */ |
| 1500 void | |
| 1501 __putDebugStr (char *str) | |
| 1502 { | |
| 1503 while (*str) | |
| 1504 { | |
| 1505 putDebugChar (*str); | |
| 1506 str++; | |
| 1507 } | |
| 1508 } | |
| 1509 | |
| 1510 /* Send STRING_LEN bytes of STR to GDB, using 'O' packets. | |
| 1511 STR is assumed to be in the program being debugged. */ | |
| 1512 | |
| 0 | 1513 int |
| 2 | 1514 __output_gdb_string (target_register_t str, int string_len) |
| 0 | 1515 { |
| 2 | 1516 /* We will arbitrarily limit output packets to less than 400 bytes. */ |
| 1517 static char buf[400]; | |
| 0 | 1518 int x; |
| 1519 int len; | |
| 1520 | |
| 1521 if (string_len == 0) | |
| 2 | 1522 { |
| 1523 /* We can't do strlen on a user pointer. */ | |
| 1524 return -1; | |
| 1525 } | |
| 0 | 1526 |
| 2 | 1527 len = string_len; |
| 1528 while (len > 0) | |
| 0 | 1529 { |
| 2 | 1530 int packetlen = ((len < 175) ? len : 175); |
| 1531 buf[0] = 'O'; | |
| 1532 for (x = 0; x < packetlen; x++) | |
| 1533 { | |
| 1534 char c; | |
| 1535 | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1536 __read_mem_safe (&c, (void *)(str + x), 1); |
| 2 | 1537 buf[x*2+1] = hexchars[(c >> 4) & 0xf]; |
| 1538 buf[x*2+2] = hexchars[c % 16]; | |
| 1539 } | |
| 1540 str += x; | |
| 1541 len -= x; | |
| 1542 buf[x*2+1] = 0; | |
| 1543 __putpacket (buf); | |
| 0 | 1544 } |
| 1545 return string_len; | |
| 1546 } | |
| 1547 | |
| 1548 static void | |
| 1549 do_nothing (void) | |
| 1550 { | |
| 1551 /* mmmm */ | |
| 1552 } | |
| 1553 | |
| 1554 static int | |
| 1555 syscall_do_nothing (int junk) | |
| 1556 { | |
| 1557 return 0; | |
| 1558 } | |
| 1559 | |
| 1560 /* Start the stub running. */ | |
| 1561 void | |
| 2 | 1562 __switch_to_stub (void) |
| 0 | 1563 { |
| 1564 __process_exception_vec = process_exception; | |
|
112
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1565 #ifdef CYGPKG_CYGMON |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1566 // Cygmon will have consumed the '$' character for this packet. |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1567 // Let's put one in the unget buffer. |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1568 // Actually, Cygmon does an unget, but since it uses different |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1569 // unget handling, we need to do this here. |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1570 ungetDebugChar('$'); |
|
02ea4320376c
Merge from eCos master repository on 2000-07-21-21:01:39-BST
jlarmour
parents:
78
diff
changeset
|
1571 #endif |
| 0 | 1572 } |
| 1573 | |
| 2 | 1574 #if ! defined(BOARD_SPECIFIC_STUB_INIT) |
| 1575 void | |
| 1576 initialize_stub (void) | |
| 1577 { | |
| 1578 set_debug_traps (); | |
| 1579 /* FIXME: This function should be renamed to specifically init the | |
| 1580 hardware required by debug operations. If initHardware is implemented at | |
| 1581 all, it should be called before main (). | |
| 1582 */ | |
| 1583 initHardware () ; | |
| 1584 /* This acks any stale packets , NOT an effective solution */ | |
| 1585 putDebugChar ('+'); | |
| 1586 } | |
| 1587 #endif | |
| 1588 | |
| 0 | 1589 void |
| 1590 ungetDebugChar (int c) | |
| 1591 { | |
| 1592 ungot_char = c; | |
| 1593 } | |
| 1594 | |
| 2 | 1595 void |
| 1596 __kill_program (int sigval) | |
| 0 | 1597 { |
| 1598 remcomOutBuffer[0] = 'X'; | |
| 1599 remcomOutBuffer[1] = hexchars[(sigval >> 4) & 15]; | |
| 1600 remcomOutBuffer[2] = hexchars[sigval & 15]; | |
| 1601 remcomOutBuffer[3] = 0; | |
| 2 | 1602 __putpacket (remcomOutBuffer); |
| 1603 } | |
| 1604 | |
| 1605 #define MAX_ARG_COUNT 20 | |
| 1606 #define MAX_ARGDATA 128 | |
| 1607 | |
| 1608 static char *program_argv [MAX_ARG_COUNT]; | |
| 1609 static int program_argc; | |
| 1610 static int last_program_arg; | |
| 1611 static char program_argstr [MAX_ARGDATA], *argptr; | |
| 1612 static int args_initted = 0; | |
| 1613 | |
| 1614 void | |
| 1615 __free_program_args (void) | |
| 1616 { | |
| 1617 last_program_arg = -1; | |
| 1618 program_argc = 0; | |
| 1619 program_argv [0] = NULL; | |
| 1620 argptr = program_argstr; | |
| 1621 args_initted = 1; | |
| 1622 } | |
| 1623 | |
| 1624 static char * | |
| 1625 __add_program_arg (int argc, uint32 len) | |
| 1626 { | |
| 1627 char *res; | |
| 1628 | |
| 1629 if (! args_initted) | |
| 1630 { | |
| 1631 __free_program_args (); | |
| 1632 } | |
| 1633 | |
| 1634 if ((argc >= (MAX_ARG_COUNT - 1)) | |
| 1635 || ((argptr - program_argstr + len) > MAX_ARGDATA)) | |
| 1636 { | |
| 1637 return NULL; | |
| 1638 } | |
| 1639 | |
| 1640 if (argc != last_program_arg) | |
| 1641 { | |
| 1642 if (argc >= program_argc) | |
| 1643 { | |
| 1644 program_argc = argc + 1; | |
| 1645 program_argv [program_argc] = NULL; | |
| 1646 } | |
| 1647 program_argv [argc] = argptr; | |
| 1648 last_program_arg = argc; | |
| 1649 } | |
| 1650 | |
| 1651 res = argptr; | |
| 1652 argptr += len; | |
| 1653 | |
| 1654 return res; | |
| 1655 } | |
| 1656 | |
| 1657 void | |
| 1658 __set_program_args (int argc, char **argv) | |
| 1659 { | |
| 1660 int x; | |
| 1661 | |
| 1662 __free_program_args (); | |
| 1663 if (argc) | |
| 1664 { | |
| 1665 for (x = 0; x < argc; x++) | |
| 1666 { | |
| 1667 uint32 len = strlen (argv[x])+1; | |
| 1668 char *s = __add_program_arg (x, len); | |
| 1669 | |
| 1670 if (s == NULL) | |
| 1671 return; | |
| 1672 | |
| 1673 memcpy (s, argv[x], len); | |
| 1674 } | |
| 1675 } | |
| 1676 } | |
| 1677 | |
| 1678 char ** | |
| 1679 __get_program_args (target_register_t argcPtr) | |
| 1680 { | |
| 1681 if (!args_initted) | |
| 1682 { | |
| 1683 __free_program_args (); | |
| 1684 } | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1685 __write_mem_safe ((char *) &program_argc, (void *)argcPtr, sizeof (program_argc)); |
| 2 | 1686 return program_argv; |
| 0 | 1687 } |
| 1688 | |
| 1689 /* Table used by the crc32 function to calcuate the checksum. */ | |
| 1690 static uint32 crc32_table[256]; | |
| 1691 static int tableInit = 0; | |
| 1692 | |
| 1693 /* | |
| 1694 Calculate a CRC-32 using LEN bytes of PTR. CRC is the initial CRC | |
| 1695 value. | |
| 1696 PTR is assumed to be a pointer in the user program. */ | |
| 1697 | |
| 1698 static uint32 | |
| 2 | 1699 crc32 (ptr, len, crc) |
| 1700 unsigned char *ptr; | |
| 1701 int len; | |
| 1702 uint32 crc; | |
| 0 | 1703 { |
| 1704 if (! tableInit) | |
| 1705 { | |
| 1706 /* Initialize the CRC table and the decoding table. */ | |
| 1707 uint32 i, j; | |
| 1708 uint32 c; | |
| 1709 | |
| 1710 tableInit = 1; | |
| 1711 for (i = 0; i < 256; i++) | |
| 2 | 1712 { |
| 1713 for (c = i << 24, j = 8; j > 0; --j) | |
| 1714 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); | |
| 1715 crc32_table[i] = c; | |
| 1716 } | |
| 0 | 1717 } |
| 1718 | |
| 1719 __mem_fault = 0; | |
| 1720 while (len--) | |
| 1721 { | |
| 1722 unsigned char ch; | |
| 1723 | |
|
34
29bc183297e1
Merge from eCos master repository on 1999-09-02-16:26:10-BST
jlarmour
parents:
28
diff
changeset
|
1724 __read_mem_safe (&ch, (void *)ptr, 1); |
| 0 | 1725 if (__mem_fault) |
| 2 | 1726 { |
| 1727 break; | |
| 1728 } | |
| 0 | 1729 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ ch) & 255]; |
| 1730 ptr++; | |
| 1731 } | |
| 1732 return crc; | |
| 1733 } | |
| 1734 | |
| 1735 /* Handle the 'q' request */ | |
| 1736 | |
| 1737 static void | |
| 1738 process_query (char *pkt) | |
| 1739 { | |
| 1740 remcomOutBuffer[0] = '\0'; | |
| 2 | 1741 #ifdef __ECOS__ |
| 0 | 1742 if ('C' == pkt[0] && |
| 1743 'R' == pkt[1] && | |
| 1744 'C' == pkt[2] && | |
| 1745 ':' == pkt[3]) | |
| 2 | 1746 #else // __ECOS__ |
| 1747 if (strncmp (pkt, "CRC:", 4) == 0) | |
| 1748 #endif // __ECOS__ | |
| 0 | 1749 { |
| 1750 target_register_t startmem; | |
| 1751 target_register_t length; | |
| 1752 uint32 our_crc; | |
| 1753 | |
| 1754 pkt += 4; | |
| 1755 if (__hexToInt (&pkt, &startmem) | |
| 2 | 1756 && *(pkt++) == ',' |
| 1757 && __hexToInt (&pkt, &length)) | |
| 1758 { | |
| 1759 our_crc = crc32 ((unsigned char *) startmem, length, 0xffffffff); | |
| 1760 if (__mem_fault) | |
| 1761 { | |
| 1762 strcpy (remcomOutBuffer, "E01"); | |
| 1763 } | |
| 1764 else | |
| 1765 { | |
| 1766 int numb = __intToHex (remcomOutBuffer + 1, our_crc, 32); | |
| 1767 remcomOutBuffer[0] = 'C'; | |
| 1768 remcomOutBuffer[numb + 1] = 0; | |
| 1769 } | |
| 1770 } | |
| 0 | 1771 return; |
| 1772 } | |
| 1773 else | |
| 1774 { | |
| 1775 char ch ; | |
| 1776 char * subpkt ; | |
| 1777 ch = *pkt ; | |
| 1778 subpkt = pkt + 1 ; | |
| 1779 switch (ch) | |
| 2 | 1780 { |
| 1781 case 'L' : /* threadlistquery */ | |
| 1782 STUB_PKT_GETTHREADLIST (subpkt, remcomOutBuffer, 300); | |
| 1783 break ; | |
| 1784 case 'P' : /* Thread or process information request */ | |
| 1785 STUB_PKT_GETTHREADINFO (subpkt, remcomOutBuffer, 300); | |
| 1786 break ; | |
| 1787 case 'C' : /* current thread query */ | |
| 1788 STUB_PKT_CURRTHREAD(subpkt, remcomOutBuffer, sizeof(remcomOutBuffer)); | |
| 1789 break; | |
| 1790 default: | |
| 1791 __process_target_query (pkt, remcomOutBuffer, 300); | |
| 1792 break ; | |
| 1793 } | |
| 0 | 1794 } |
| 1795 } | |
| 1796 | |
| 1797 /* Handle the 'Q' request */ | |
| 1798 | |
| 1799 static void | |
| 1800 process_set (char *pkt) | |
| 1801 { | |
| 1802 char ch ; | |
| 1803 ch = *pkt ; | |
| 1804 | |
| 1805 switch (ch) | |
| 1806 { | |
| 1807 case 'p' : /* Set current process or thread */ | |
| 1808 /* reserve the packet id even if support is not present */ | |
| 1809 /* Dont strip the 'p' off the header, there are several variations of | |
| 2 | 1810 this packet */ |
| 0 | 1811 STUB_PKT_CHANGETHREAD (pkt, remcomOutBuffer, 300) ; |
| 1812 break ; | |
| 1813 default: | |
| 1814 __process_target_set (pkt, remcomOutBuffer, 300); | |
| 1815 break ; | |
| 1816 } | |
| 1817 } | |
| 1818 #endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS |