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