Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /*!************************************************************************** |
2 | *! | |
3 | *! FILE NAME : kgdb.c | |
4 | *! | |
5 | *! DESCRIPTION: Implementation of the gdb stub with respect to ETRAX 100. | |
6 | *! It is a mix of arch/m68k/kernel/kgdb.c and cris_stub.c. | |
7 | *! | |
8 | *!--------------------------------------------------------------------------- | |
9 | *! HISTORY | |
10 | *! | |
11 | *! DATE NAME CHANGES | |
12 | *! ---- ---- ------- | |
13 | *! Apr 26 1999 Hendrik Ruijter Initial version. | |
14 | *! May 6 1999 Hendrik Ruijter Removed call to strlen in libc and removed | |
15 | *! struct assignment as it generates calls to | |
16 | *! memcpy in libc. | |
17 | *! Jun 17 1999 Hendrik Ruijter Added gdb 4.18 support. 'X', 'qC' and 'qL'. | |
18 | *! Jul 21 1999 Bjorn Wesen eLinux port | |
19 | *! | |
1da177e4 LT |
20 | *!--------------------------------------------------------------------------- |
21 | *! | |
1da177e4 LT |
22 | *! (C) Copyright 1999, Axis Communications AB, LUND, SWEDEN |
23 | *! | |
24 | *!**************************************************************************/ | |
25 | /* @(#) cris_stub.c 1.3 06/17/99 */ | |
26 | ||
27 | /* | |
28 | * kgdb usage notes: | |
29 | * ----------------- | |
30 | * | |
31 | * If you select CONFIG_ETRAX_KGDB in the configuration, the kernel will be | |
32 | * built with different gcc flags: "-g" is added to get debug infos, and | |
33 | * "-fomit-frame-pointer" is omitted to make debugging easier. Since the | |
34 | * resulting kernel will be quite big (approx. > 7 MB), it will be stripped | |
35 | * before compresion. Such a kernel will behave just as usually, except if | |
36 | * given a "debug=<device>" command line option. (Only serial devices are | |
37 | * allowed for <device>, i.e. no printers or the like; possible values are | |
38 | * machine depedend and are the same as for the usual debug device, the one | |
39 | * for logging kernel messages.) If that option is given and the device can be | |
40 | * initialized, the kernel will connect to the remote gdb in trap_init(). The | |
41 | * serial parameters are fixed to 8N1 and 115200 bps, for easyness of | |
42 | * implementation. | |
43 | * | |
44 | * To start a debugging session, start that gdb with the debugging kernel | |
45 | * image (the one with the symbols, vmlinux.debug) named on the command line. | |
46 | * This file will be used by gdb to get symbol and debugging infos about the | |
47 | * kernel. Next, select remote debug mode by | |
48 | * target remote <device> | |
49 | * where <device> is the name of the serial device over which the debugged | |
50 | * machine is connected. Maybe you have to adjust the baud rate by | |
51 | * set remotebaud <rate> | |
52 | * or also other parameters with stty: | |
53 | * shell stty ... </dev/... | |
54 | * If the kernel to debug has already booted, it waited for gdb and now | |
55 | * connects, and you'll see a breakpoint being reported. If the kernel isn't | |
56 | * running yet, start it now. The order of gdb and the kernel doesn't matter. | |
57 | * Another thing worth knowing about in the getting-started phase is how to | |
58 | * debug the remote protocol itself. This is activated with | |
59 | * set remotedebug 1 | |
60 | * gdb will then print out each packet sent or received. You'll also get some | |
61 | * messages about the gdb stub on the console of the debugged machine. | |
62 | * | |
63 | * If all that works, you can use lots of the usual debugging techniques on | |
64 | * the kernel, e.g. inspecting and changing variables/memory, setting | |
65 | * breakpoints, single stepping and so on. It's also possible to interrupt the | |
66 | * debugged kernel by pressing C-c in gdb. Have fun! :-) | |
67 | * | |
68 | * The gdb stub is entered (and thus the remote gdb gets control) in the | |
69 | * following situations: | |
70 | * | |
71 | * - If breakpoint() is called. This is just after kgdb initialization, or if | |
72 | * a breakpoint() call has been put somewhere into the kernel source. | |
73 | * (Breakpoints can of course also be set the usual way in gdb.) | |
74 | * In eLinux, we call breakpoint() in init/main.c after IRQ initialization. | |
75 | * | |
76 | * - If there is a kernel exception, i.e. bad_super_trap() or die_if_kernel() | |
77 | * are entered. All the CPU exceptions are mapped to (more or less..., see | |
78 | * the hard_trap_info array below) appropriate signal, which are reported | |
79 | * to gdb. die_if_kernel() is usually called after some kind of access | |
80 | * error and thus is reported as SIGSEGV. | |
81 | * | |
82 | * - When panic() is called. This is reported as SIGABRT. | |
83 | * | |
84 | * - If C-c is received over the serial line, which is treated as | |
85 | * SIGINT. | |
86 | * | |
87 | * Of course, all these signals are just faked for gdb, since there is no | |
88 | * signal concept as such for the kernel. It also isn't possible --obviously-- | |
89 | * to set signal handlers from inside gdb, or restart the kernel with a | |
90 | * signal. | |
91 | * | |
92 | * Current limitations: | |
93 | * | |
94 | * - While the kernel is stopped, interrupts are disabled for safety reasons | |
95 | * (i.e., variables not changing magically or the like). But this also | |
96 | * means that the clock isn't running anymore, and that interrupts from the | |
97 | * hardware may get lost/not be served in time. This can cause some device | |
98 | * errors... | |
99 | * | |
100 | * - When single-stepping, only one instruction of the current thread is | |
101 | * executed, but interrupts are allowed for that time and will be serviced | |
102 | * if pending. Be prepared for that. | |
103 | * | |
104 | * - All debugging happens in kernel virtual address space. There's no way to | |
105 | * access physical memory not mapped in kernel space, or to access user | |
106 | * space. A way to work around this is using get_user_long & Co. in gdb | |
107 | * expressions, but only for the current process. | |
108 | * | |
109 | * - Interrupting the kernel only works if interrupts are currently allowed, | |
110 | * and the interrupt of the serial line isn't blocked by some other means | |
111 | * (IPL too high, disabled, ...) | |
112 | * | |
113 | * - The gdb stub is currently not reentrant, i.e. errors that happen therein | |
114 | * (e.g. accessing invalid memory) may not be caught correctly. This could | |
115 | * be removed in future by introducing a stack of struct registers. | |
116 | * | |
117 | */ | |
118 | ||
119 | /* | |
120 | * To enable debugger support, two things need to happen. One, a | |
121 | * call to kgdb_init() is necessary in order to allow any breakpoints | |
122 | * or error conditions to be properly intercepted and reported to gdb. | |
123 | * Two, a breakpoint needs to be generated to begin communication. This | |
124 | * is most easily accomplished by a call to breakpoint(). | |
125 | * | |
126 | * The following gdb commands are supported: | |
127 | * | |
128 | * command function Return value | |
129 | * | |
130 | * g return the value of the CPU registers hex data or ENN | |
131 | * G set the value of the CPU registers OK or ENN | |
132 | * | |
133 | * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN | |
134 | * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN | |
135 | * | |
136 | * c Resume at current address SNN ( signal NN) | |
137 | * cAA..AA Continue at address AA..AA SNN | |
138 | * | |
139 | * s Step one instruction SNN | |
140 | * sAA..AA Step one instruction from AA..AA SNN | |
141 | * | |
142 | * k kill | |
143 | * | |
144 | * ? What was the last sigval ? SNN (signal NN) | |
145 | * | |
146 | * bBB..BB Set baud rate to BB..BB OK or BNN, then sets | |
147 | * baud rate | |
148 | * | |
149 | * All commands and responses are sent with a packet which includes a | |
150 | * checksum. A packet consists of | |
151 | * | |
152 | * $<packet info>#<checksum>. | |
153 | * | |
154 | * where | |
155 | * <packet info> :: <characters representing the command or response> | |
156 | * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>> | |
157 | * | |
158 | * When a packet is received, it is first acknowledged with either '+' or '-'. | |
159 | * '+' indicates a successful transfer. '-' indicates a failed transfer. | |
160 | * | |
161 | * Example: | |
162 | * | |
163 | * Host: Reply: | |
164 | * $m0,10#2a +$00010203040506070809101112131415#42 | |
165 | * | |
166 | */ | |
167 | ||
168 | ||
169 | #include <linux/string.h> | |
170 | #include <linux/signal.h> | |
171 | #include <linux/kernel.h> | |
172 | #include <linux/delay.h> | |
173 | #include <linux/linkage.h> | |
7cf32cad | 174 | #include <linux/reboot.h> |
1da177e4 LT |
175 | |
176 | #include <asm/setup.h> | |
177 | #include <asm/ptrace.h> | |
178 | ||
556dcee7 | 179 | #include <arch/svinto.h> |
1da177e4 LT |
180 | #include <asm/irq.h> |
181 | ||
182 | static int kgdb_started = 0; | |
183 | ||
184 | /********************************* Register image ****************************/ | |
185 | /* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's | |
186 | Reference", p. 1-1, with the additional register definitions of the | |
187 | ETRAX 100LX in cris-opc.h. | |
188 | There are 16 general 32-bit registers, R0-R15, where R14 is the stack | |
189 | pointer, SP, and R15 is the program counter, PC. | |
190 | There are 16 special registers, P0-P15, where three of the unimplemented | |
191 | registers, P0, P4 and P8, are reserved as zero-registers. A read from | |
192 | any of these registers returns zero and a write has no effect. */ | |
193 | ||
194 | typedef | |
195 | struct register_image | |
196 | { | |
197 | /* Offset */ | |
198 | unsigned int r0; /* 0x00 */ | |
199 | unsigned int r1; /* 0x04 */ | |
200 | unsigned int r2; /* 0x08 */ | |
201 | unsigned int r3; /* 0x0C */ | |
202 | unsigned int r4; /* 0x10 */ | |
203 | unsigned int r5; /* 0x14 */ | |
204 | unsigned int r6; /* 0x18 */ | |
205 | unsigned int r7; /* 0x1C */ | |
206 | unsigned int r8; /* 0x20 Frame pointer */ | |
207 | unsigned int r9; /* 0x24 */ | |
208 | unsigned int r10; /* 0x28 */ | |
209 | unsigned int r11; /* 0x2C */ | |
210 | unsigned int r12; /* 0x30 */ | |
211 | unsigned int r13; /* 0x34 */ | |
212 | unsigned int sp; /* 0x38 Stack pointer */ | |
213 | unsigned int pc; /* 0x3C Program counter */ | |
214 | ||
215 | unsigned char p0; /* 0x40 8-bit zero-register */ | |
216 | unsigned char vr; /* 0x41 Version register */ | |
217 | ||
218 | unsigned short p4; /* 0x42 16-bit zero-register */ | |
219 | unsigned short ccr; /* 0x44 Condition code register */ | |
220 | ||
221 | unsigned int mof; /* 0x46 Multiply overflow register */ | |
222 | ||
223 | unsigned int p8; /* 0x4A 32-bit zero-register */ | |
224 | unsigned int ibr; /* 0x4E Interrupt base register */ | |
225 | unsigned int irp; /* 0x52 Interrupt return pointer */ | |
226 | unsigned int srp; /* 0x56 Subroutine return pointer */ | |
227 | unsigned int bar; /* 0x5A Breakpoint address register */ | |
228 | unsigned int dccr; /* 0x5E Double condition code register */ | |
229 | unsigned int brp; /* 0x62 Breakpoint return pointer (pc in caller) */ | |
230 | unsigned int usp; /* 0x66 User mode stack pointer */ | |
231 | } registers; | |
232 | ||
233 | /************** Prototypes for local library functions ***********************/ | |
234 | ||
235 | /* Copy of strcpy from libc. */ | |
236 | static char *gdb_cris_strcpy (char *s1, const char *s2); | |
237 | ||
238 | /* Copy of strlen from libc. */ | |
239 | static int gdb_cris_strlen (const char *s); | |
240 | ||
241 | /* Copy of memchr from libc. */ | |
242 | static void *gdb_cris_memchr (const void *s, int c, int n); | |
243 | ||
244 | /* Copy of strtol from libc. Does only support base 16. */ | |
245 | static int gdb_cris_strtol (const char *s, char **endptr, int base); | |
246 | ||
247 | /********************** Prototypes for local functions. **********************/ | |
248 | /* Copy the content of a register image into another. The size n is | |
249 | the size of the register image. Due to struct assignment generation of | |
250 | memcpy in libc. */ | |
251 | static void copy_registers (registers *dptr, registers *sptr, int n); | |
252 | ||
253 | /* Copy the stored registers from the stack. Put the register contents | |
254 | of thread thread_id in the struct reg. */ | |
255 | static void copy_registers_from_stack (int thread_id, registers *reg); | |
256 | ||
257 | /* Copy the registers to the stack. Put the register contents of thread | |
258 | thread_id from struct reg to the stack. */ | |
259 | static void copy_registers_to_stack (int thread_id, registers *reg); | |
260 | ||
261 | /* Write a value to a specified register regno in the register image | |
262 | of the current thread. */ | |
263 | static int write_register (int regno, char *val); | |
264 | ||
265 | /* Write a value to a specified register in the stack of a thread other | |
266 | than the current thread. */ | |
267 | static write_stack_register (int thread_id, int regno, char *valptr); | |
268 | ||
269 | /* Read a value from a specified register in the register image. Returns the | |
270 | status of the read operation. The register value is returned in valptr. */ | |
271 | static int read_register (char regno, unsigned int *valptr); | |
272 | ||
273 | /* Serial port, reads one character. ETRAX 100 specific. from debugport.c */ | |
274 | int getDebugChar (void); | |
275 | ||
276 | /* Serial port, writes one character. ETRAX 100 specific. from debugport.c */ | |
277 | void putDebugChar (int val); | |
278 | ||
279 | void enableDebugIRQ (void); | |
280 | ||
1da177e4 LT |
281 | /* Returns the integer equivalent of a hexadecimal character. */ |
282 | static int hex (char ch); | |
283 | ||
284 | /* Convert the memory, pointed to by mem into hexadecimal representation. | |
285 | Put the result in buf, and return a pointer to the last character | |
286 | in buf (null). */ | |
287 | static char *mem2hex (char *buf, unsigned char *mem, int count); | |
288 | ||
289 | /* Convert the array, in hexadecimal representation, pointed to by buf into | |
290 | binary representation. Put the result in mem, and return a pointer to | |
291 | the character after the last byte written. */ | |
292 | static unsigned char *hex2mem (unsigned char *mem, char *buf, int count); | |
293 | ||
294 | /* Put the content of the array, in binary representation, pointed to by buf | |
295 | into memory pointed to by mem, and return a pointer to | |
296 | the character after the last byte written. */ | |
297 | static unsigned char *bin2mem (unsigned char *mem, unsigned char *buf, int count); | |
298 | ||
299 | /* Await the sequence $<data>#<checksum> and store <data> in the array buffer | |
300 | returned. */ | |
301 | static void getpacket (char *buffer); | |
302 | ||
303 | /* Send $<data>#<checksum> from the <data> in the array buffer. */ | |
304 | static void putpacket (char *buffer); | |
305 | ||
306 | /* Build and send a response packet in order to inform the host the | |
307 | stub is stopped. */ | |
308 | static void stub_is_stopped (int sigval); | |
309 | ||
310 | /* All expected commands are sent from remote.c. Send a response according | |
311 | to the description in remote.c. */ | |
312 | static void handle_exception (int sigval); | |
313 | ||
314 | /* Performs a complete re-start from scratch. ETRAX specific. */ | |
315 | static void kill_restart (void); | |
316 | ||
317 | /******************** Prototypes for global functions. ***********************/ | |
318 | ||
319 | /* The string str is prepended with the GDB printout token and sent. */ | |
320 | void putDebugString (const unsigned char *str, int length); /* used by etrax100ser.c */ | |
321 | ||
322 | /* The hook for both static (compiled) and dynamic breakpoints set by GDB. | |
323 | ETRAX 100 specific. */ | |
324 | void handle_breakpoint (void); /* used by irq.c */ | |
325 | ||
326 | /* The hook for an interrupt generated by GDB. ETRAX 100 specific. */ | |
327 | void handle_interrupt (void); /* used by irq.c */ | |
328 | ||
329 | /* A static breakpoint to be used at startup. */ | |
330 | void breakpoint (void); /* called by init/main.c */ | |
331 | ||
332 | /* From osys_int.c, executing_task contains the number of the current | |
333 | executing task in osys. Does not know of object-oriented threads. */ | |
334 | extern unsigned char executing_task; | |
335 | ||
336 | /* The number of characters used for a 64 bit thread identifier. */ | |
337 | #define HEXCHARS_IN_THREAD_ID 16 | |
338 | ||
339 | /* Avoid warning as the internal_stack is not used in the C-code. */ | |
340 | #define USEDVAR(name) { if (name) { ; } } | |
341 | #define USEDFUN(name) { void (*pf)(void) = (void *)name; USEDVAR(pf) } | |
342 | ||
343 | /********************************** Packet I/O ******************************/ | |
344 | /* BUFMAX defines the maximum number of characters in | |
345 | inbound/outbound buffers */ | |
346 | #define BUFMAX 512 | |
347 | ||
348 | /* Run-length encoding maximum length. Send 64 at most. */ | |
349 | #define RUNLENMAX 64 | |
350 | ||
1da177e4 LT |
351 | /* The inbound/outbound buffers used in packet I/O */ |
352 | static char remcomInBuffer[BUFMAX]; | |
353 | static char remcomOutBuffer[BUFMAX]; | |
354 | ||
355 | /* Error and warning messages. */ | |
356 | enum error_type | |
357 | { | |
358 | SUCCESS, E01, E02, E03, E04, E05, E06, E07 | |
359 | }; | |
360 | static char *error_message[] = | |
361 | { | |
362 | "", | |
363 | "E01 Set current or general thread - H[c,g] - internal error.", | |
364 | "E02 Change register content - P - cannot change read-only register.", | |
365 | "E03 Thread is not alive.", /* T, not used. */ | |
366 | "E04 The command is not supported - [s,C,S,!,R,d,r] - internal error.", | |
367 | "E05 Change register content - P - the register is not implemented..", | |
368 | "E06 Change memory content - M - internal error.", | |
369 | "E07 Change register content - P - the register is not stored on the stack" | |
370 | }; | |
371 | /********************************* Register image ****************************/ | |
372 | /* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's | |
373 | Reference", p. 1-1, with the additional register definitions of the | |
374 | ETRAX 100LX in cris-opc.h. | |
375 | There are 16 general 32-bit registers, R0-R15, where R14 is the stack | |
376 | pointer, SP, and R15 is the program counter, PC. | |
377 | There are 16 special registers, P0-P15, where three of the unimplemented | |
378 | registers, P0, P4 and P8, are reserved as zero-registers. A read from | |
379 | any of these registers returns zero and a write has no effect. */ | |
380 | enum register_name | |
381 | { | |
382 | R0, R1, R2, R3, | |
383 | R4, R5, R6, R7, | |
384 | R8, R9, R10, R11, | |
385 | R12, R13, SP, PC, | |
386 | P0, VR, P2, P3, | |
387 | P4, CCR, P6, MOF, | |
388 | P8, IBR, IRP, SRP, | |
389 | BAR, DCCR, BRP, USP | |
390 | }; | |
391 | ||
392 | /* The register sizes of the registers in register_name. An unimplemented register | |
393 | is designated by size 0 in this array. */ | |
394 | static int register_size[] = | |
395 | { | |
396 | 4, 4, 4, 4, | |
397 | 4, 4, 4, 4, | |
398 | 4, 4, 4, 4, | |
399 | 4, 4, 4, 4, | |
400 | 1, 1, 0, 0, | |
401 | 2, 2, 0, 4, | |
402 | 4, 4, 4, 4, | |
403 | 4, 4, 4, 4 | |
404 | }; | |
405 | ||
406 | /* Contains the register image of the executing thread in the assembler | |
407 | part of the code in order to avoid horrible addressing modes. */ | |
408 | static registers reg; | |
409 | ||
410 | /* FIXME: Should this be used? Delete otherwise. */ | |
411 | /* Contains the assumed consistency state of the register image. Uses the | |
412 | enum error_type for state information. */ | |
413 | static int consistency_status = SUCCESS; | |
414 | ||
415 | /********************************** Handle exceptions ************************/ | |
416 | /* The variable reg contains the register image associated with the | |
417 | current_thread_c variable. It is a complete register image created at | |
418 | entry. The reg_g contains a register image of a task where the general | |
419 | registers are taken from the stack and all special registers are taken | |
420 | from the executing task. It is associated with current_thread_g and used | |
421 | in order to provide access mainly for 'g', 'G' and 'P'. | |
422 | */ | |
423 | ||
424 | /* Need two task id pointers in order to handle Hct and Hgt commands. */ | |
425 | static int current_thread_c = 0; | |
426 | static int current_thread_g = 0; | |
427 | ||
428 | /* Need two register images in order to handle Hct and Hgt commands. The | |
429 | variable reg_g is in addition to reg above. */ | |
430 | static registers reg_g; | |
431 | ||
432 | /********************************** Breakpoint *******************************/ | |
433 | /* Use an internal stack in the breakpoint and interrupt response routines */ | |
434 | #define INTERNAL_STACK_SIZE 1024 | |
435 | static char internal_stack[INTERNAL_STACK_SIZE]; | |
436 | ||
437 | /* Due to the breakpoint return pointer, a state variable is needed to keep | |
438 | track of whether it is a static (compiled) or dynamic (gdb-invoked) | |
439 | breakpoint to be handled. A static breakpoint uses the content of register | |
440 | BRP as it is whereas a dynamic breakpoint requires subtraction with 2 | |
441 | in order to execute the instruction. The first breakpoint is static. */ | |
442 | static unsigned char is_dyn_brkp = 0; | |
443 | ||
444 | /********************************* String library ****************************/ | |
445 | /* Single-step over library functions creates trap loops. */ | |
446 | ||
447 | /* Copy char s2[] to s1[]. */ | |
448 | static char* | |
449 | gdb_cris_strcpy (char *s1, const char *s2) | |
450 | { | |
451 | char *s = s1; | |
452 | ||
453 | for (s = s1; (*s++ = *s2++) != '\0'; ) | |
454 | ; | |
455 | return (s1); | |
456 | } | |
457 | ||
458 | /* Find length of s[]. */ | |
459 | static int | |
460 | gdb_cris_strlen (const char *s) | |
461 | { | |
462 | const char *sc; | |
463 | ||
464 | for (sc = s; *sc != '\0'; sc++) | |
465 | ; | |
466 | return (sc - s); | |
467 | } | |
468 | ||
469 | /* Find first occurrence of c in s[n]. */ | |
470 | static void* | |
471 | gdb_cris_memchr (const void *s, int c, int n) | |
472 | { | |
473 | const unsigned char uc = c; | |
474 | const unsigned char *su; | |
475 | ||
476 | for (su = s; 0 < n; ++su, --n) | |
477 | if (*su == uc) | |
478 | return ((void *)su); | |
479 | return (NULL); | |
480 | } | |
481 | /******************************* Standard library ****************************/ | |
482 | /* Single-step over library functions creates trap loops. */ | |
483 | /* Convert string to long. */ | |
484 | static int | |
485 | gdb_cris_strtol (const char *s, char **endptr, int base) | |
486 | { | |
487 | char *s1; | |
488 | char *sd; | |
489 | int x = 0; | |
490 | ||
42a9a583 HH |
491 | for (s1 = (char*)s; (sd = gdb_cris_memchr(hex_asc, *s1, base)) != NULL; ++s1) |
492 | x = x * base + (sd - hex_asc); | |
1da177e4 LT |
493 | |
494 | if (endptr) | |
495 | { | |
496 | /* Unconverted suffix is stored in endptr unless endptr is NULL. */ | |
497 | *endptr = s1; | |
498 | } | |
499 | ||
500 | return x; | |
501 | } | |
502 | ||
1da177e4 LT |
503 | /********************************* Register image ****************************/ |
504 | /* Copy the content of a register image into another. The size n is | |
505 | the size of the register image. Due to struct assignment generation of | |
506 | memcpy in libc. */ | |
507 | static void | |
508 | copy_registers (registers *dptr, registers *sptr, int n) | |
509 | { | |
510 | unsigned char *dreg; | |
511 | unsigned char *sreg; | |
512 | ||
513 | for (dreg = (unsigned char*)dptr, sreg = (unsigned char*)sptr; n > 0; n--) | |
514 | *dreg++ = *sreg++; | |
515 | } | |
516 | ||
517 | #ifdef PROCESS_SUPPORT | |
518 | /* Copy the stored registers from the stack. Put the register contents | |
519 | of thread thread_id in the struct reg. */ | |
520 | static void | |
521 | copy_registers_from_stack (int thread_id, registers *regptr) | |
522 | { | |
523 | int j; | |
524 | stack_registers *s = (stack_registers *)stack_list[thread_id]; | |
525 | unsigned int *d = (unsigned int *)regptr; | |
526 | ||
527 | for (j = 13; j >= 0; j--) | |
528 | *d++ = s->r[j]; | |
529 | regptr->sp = (unsigned int)stack_list[thread_id]; | |
530 | regptr->pc = s->pc; | |
531 | regptr->dccr = s->dccr; | |
532 | regptr->srp = s->srp; | |
533 | } | |
534 | ||
535 | /* Copy the registers to the stack. Put the register contents of thread | |
536 | thread_id from struct reg to the stack. */ | |
537 | static void | |
538 | copy_registers_to_stack (int thread_id, registers *regptr) | |
539 | { | |
540 | int i; | |
541 | stack_registers *d = (stack_registers *)stack_list[thread_id]; | |
542 | unsigned int *s = (unsigned int *)regptr; | |
543 | ||
544 | for (i = 0; i < 14; i++) { | |
545 | d->r[i] = *s++; | |
546 | } | |
547 | d->pc = regptr->pc; | |
548 | d->dccr = regptr->dccr; | |
549 | d->srp = regptr->srp; | |
550 | } | |
551 | #endif | |
552 | ||
553 | /* Write a value to a specified register in the register image of the current | |
554 | thread. Returns status code SUCCESS, E02 or E05. */ | |
555 | static int | |
556 | write_register (int regno, char *val) | |
557 | { | |
558 | int status = SUCCESS; | |
559 | registers *current_reg = ® | |
560 | ||
561 | if (regno >= R0 && regno <= PC) { | |
562 | /* 32-bit register with simple offset. */ | |
563 | hex2mem ((unsigned char *)current_reg + regno * sizeof(unsigned int), | |
564 | val, sizeof(unsigned int)); | |
565 | } | |
566 | else if (regno == P0 || regno == VR || regno == P4 || regno == P8) { | |
567 | /* Do not support read-only registers. */ | |
568 | status = E02; | |
569 | } | |
570 | else if (regno == CCR) { | |
571 | /* 16 bit register with complex offset. (P4 is read-only, P6 is not implemented, | |
572 | and P7 (MOF) is 32 bits in ETRAX 100LX. */ | |
573 | hex2mem ((unsigned char *)&(current_reg->ccr) + (regno-CCR) * sizeof(unsigned short), | |
574 | val, sizeof(unsigned short)); | |
575 | } | |
576 | else if (regno >= MOF && regno <= USP) { | |
577 | /* 32 bit register with complex offset. (P8 has been taken care of.) */ | |
578 | hex2mem ((unsigned char *)&(current_reg->ibr) + (regno-IBR) * sizeof(unsigned int), | |
579 | val, sizeof(unsigned int)); | |
580 | } | |
581 | else { | |
582 | /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */ | |
583 | status = E05; | |
584 | } | |
585 | return status; | |
586 | } | |
587 | ||
588 | #ifdef PROCESS_SUPPORT | |
589 | /* Write a value to a specified register in the stack of a thread other | |
590 | than the current thread. Returns status code SUCCESS or E07. */ | |
591 | static int | |
592 | write_stack_register (int thread_id, int regno, char *valptr) | |
593 | { | |
594 | int status = SUCCESS; | |
595 | stack_registers *d = (stack_registers *)stack_list[thread_id]; | |
596 | unsigned int val; | |
597 | ||
598 | hex2mem ((unsigned char *)&val, valptr, sizeof(unsigned int)); | |
599 | if (regno >= R0 && regno < SP) { | |
600 | d->r[regno] = val; | |
601 | } | |
602 | else if (regno == SP) { | |
603 | stack_list[thread_id] = val; | |
604 | } | |
605 | else if (regno == PC) { | |
606 | d->pc = val; | |
607 | } | |
608 | else if (regno == SRP) { | |
609 | d->srp = val; | |
610 | } | |
611 | else if (regno == DCCR) { | |
612 | d->dccr = val; | |
613 | } | |
614 | else { | |
615 | /* Do not support registers in the current thread. */ | |
616 | status = E07; | |
617 | } | |
618 | return status; | |
619 | } | |
620 | #endif | |
621 | ||
622 | /* Read a value from a specified register in the register image. Returns the | |
623 | value in the register or -1 for non-implemented registers. | |
624 | Should check consistency_status after a call which may be E05 after changes | |
625 | in the implementation. */ | |
626 | static int | |
627 | read_register (char regno, unsigned int *valptr) | |
628 | { | |
629 | registers *current_reg = ® | |
630 | ||
631 | if (regno >= R0 && regno <= PC) { | |
632 | /* 32-bit register with simple offset. */ | |
633 | *valptr = *(unsigned int *)((char *)current_reg + regno * sizeof(unsigned int)); | |
634 | return SUCCESS; | |
635 | } | |
636 | else if (regno == P0 || regno == VR) { | |
637 | /* 8 bit register with complex offset. */ | |
638 | *valptr = (unsigned int)(*(unsigned char *) | |
639 | ((char *)&(current_reg->p0) + (regno-P0) * sizeof(char))); | |
640 | return SUCCESS; | |
641 | } | |
642 | else if (regno == P4 || regno == CCR) { | |
643 | /* 16 bit register with complex offset. */ | |
644 | *valptr = (unsigned int)(*(unsigned short *) | |
645 | ((char *)&(current_reg->p4) + (regno-P4) * sizeof(unsigned short))); | |
646 | return SUCCESS; | |
647 | } | |
648 | else if (regno >= MOF && regno <= USP) { | |
649 | /* 32 bit register with complex offset. */ | |
650 | *valptr = *(unsigned int *)((char *)&(current_reg->p8) | |
651 | + (regno-P8) * sizeof(unsigned int)); | |
652 | return SUCCESS; | |
653 | } | |
654 | else { | |
655 | /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */ | |
656 | consistency_status = E05; | |
657 | return E05; | |
658 | } | |
659 | } | |
660 | ||
661 | /********************************** Packet I/O ******************************/ | |
1da177e4 LT |
662 | /* Returns the integer equivalent of a hexadecimal character. */ |
663 | static int | |
664 | hex (char ch) | |
665 | { | |
666 | if ((ch >= 'a') && (ch <= 'f')) | |
667 | return (ch - 'a' + 10); | |
668 | if ((ch >= '0') && (ch <= '9')) | |
669 | return (ch - '0'); | |
670 | if ((ch >= 'A') && (ch <= 'F')) | |
671 | return (ch - 'A' + 10); | |
672 | return (-1); | |
673 | } | |
674 | ||
675 | /* Convert the memory, pointed to by mem into hexadecimal representation. | |
676 | Put the result in buf, and return a pointer to the last character | |
677 | in buf (null). */ | |
678 | ||
679 | static int do_printk = 0; | |
680 | ||
681 | static char * | |
682 | mem2hex(char *buf, unsigned char *mem, int count) | |
683 | { | |
684 | int i; | |
685 | int ch; | |
686 | ||
687 | if (mem == NULL) { | |
688 | /* Bogus read from m0. FIXME: What constitutes a valid address? */ | |
689 | for (i = 0; i < count; i++) { | |
690 | *buf++ = '0'; | |
691 | *buf++ = '0'; | |
692 | } | |
693 | } else { | |
694 | /* Valid mem address. */ | |
695 | for (i = 0; i < count; i++) { | |
696 | ch = *mem++; | |
42a9a583 | 697 | buf = pack_hex_byte(buf, ch); |
1da177e4 LT |
698 | } |
699 | } | |
700 | ||
701 | /* Terminate properly. */ | |
702 | *buf = '\0'; | |
703 | return (buf); | |
704 | } | |
705 | ||
706 | /* Convert the array, in hexadecimal representation, pointed to by buf into | |
707 | binary representation. Put the result in mem, and return a pointer to | |
708 | the character after the last byte written. */ | |
709 | static unsigned char* | |
710 | hex2mem (unsigned char *mem, char *buf, int count) | |
711 | { | |
712 | int i; | |
713 | unsigned char ch; | |
714 | for (i = 0; i < count; i++) { | |
715 | ch = hex (*buf++) << 4; | |
716 | ch = ch + hex (*buf++); | |
717 | *mem++ = ch; | |
718 | } | |
719 | return (mem); | |
720 | } | |
721 | ||
722 | /* Put the content of the array, in binary representation, pointed to by buf | |
723 | into memory pointed to by mem, and return a pointer to the character after | |
724 | the last byte written. | |
725 | Gdb will escape $, #, and the escape char (0x7d). */ | |
726 | static unsigned char* | |
727 | bin2mem (unsigned char *mem, unsigned char *buf, int count) | |
728 | { | |
729 | int i; | |
730 | unsigned char *next; | |
731 | for (i = 0; i < count; i++) { | |
732 | /* Check for any escaped characters. Be paranoid and | |
733 | only unescape chars that should be escaped. */ | |
734 | if (*buf == 0x7d) { | |
735 | next = buf + 1; | |
736 | if (*next == 0x3 || *next == 0x4 || *next == 0x5D) /* #, $, ESC */ | |
737 | { | |
738 | buf++; | |
739 | *buf += 0x20; | |
740 | } | |
741 | } | |
742 | *mem++ = *buf++; | |
743 | } | |
744 | return (mem); | |
745 | } | |
746 | ||
747 | /* Await the sequence $<data>#<checksum> and store <data> in the array buffer | |
748 | returned. */ | |
749 | static void | |
750 | getpacket (char *buffer) | |
751 | { | |
752 | unsigned char checksum; | |
753 | unsigned char xmitcsum; | |
754 | int i; | |
755 | int count; | |
756 | char ch; | |
757 | do { | |
758 | while ((ch = getDebugChar ()) != '$') | |
759 | /* Wait for the start character $ and ignore all other characters */; | |
760 | checksum = 0; | |
761 | xmitcsum = -1; | |
762 | count = 0; | |
763 | /* Read until a # or the end of the buffer is reached */ | |
764 | while (count < BUFMAX) { | |
765 | ch = getDebugChar (); | |
766 | if (ch == '#') | |
767 | break; | |
768 | checksum = checksum + ch; | |
769 | buffer[count] = ch; | |
770 | count = count + 1; | |
771 | } | |
772 | buffer[count] = '\0'; | |
773 | ||
774 | if (ch == '#') { | |
775 | xmitcsum = hex (getDebugChar ()) << 4; | |
776 | xmitcsum += hex (getDebugChar ()); | |
777 | if (checksum != xmitcsum) { | |
778 | /* Wrong checksum */ | |
779 | putDebugChar ('-'); | |
780 | } | |
781 | else { | |
782 | /* Correct checksum */ | |
783 | putDebugChar ('+'); | |
784 | /* If sequence characters are received, reply with them */ | |
785 | if (buffer[2] == ':') { | |
786 | putDebugChar (buffer[0]); | |
787 | putDebugChar (buffer[1]); | |
788 | /* Remove the sequence characters from the buffer */ | |
789 | count = gdb_cris_strlen (buffer); | |
790 | for (i = 3; i <= count; i++) | |
791 | buffer[i - 3] = buffer[i]; | |
792 | } | |
793 | } | |
794 | } | |
795 | } while (checksum != xmitcsum); | |
796 | } | |
797 | ||
798 | /* Send $<data>#<checksum> from the <data> in the array buffer. */ | |
799 | ||
800 | static void | |
801 | putpacket(char *buffer) | |
802 | { | |
803 | int checksum; | |
804 | int runlen; | |
805 | int encode; | |
806 | ||
807 | do { | |
808 | char *src = buffer; | |
809 | putDebugChar ('$'); | |
810 | checksum = 0; | |
811 | while (*src) { | |
812 | /* Do run length encoding */ | |
813 | putDebugChar (*src); | |
814 | checksum += *src; | |
815 | runlen = 0; | |
816 | while (runlen < RUNLENMAX && *src == src[runlen]) { | |
817 | runlen++; | |
818 | } | |
819 | if (runlen > 3) { | |
820 | /* Got a useful amount */ | |
821 | putDebugChar ('*'); | |
822 | checksum += '*'; | |
823 | encode = runlen + ' ' - 4; | |
824 | putDebugChar (encode); | |
825 | checksum += encode; | |
826 | src += runlen; | |
827 | } | |
828 | else { | |
829 | src++; | |
830 | } | |
831 | } | |
42a9a583 HH |
832 | putDebugChar('#'); |
833 | putDebugChar(hex_asc_hi(checksum)); | |
834 | putDebugChar(hex_asc_lo(checksum)); | |
1da177e4 LT |
835 | } while(kgdb_started && (getDebugChar() != '+')); |
836 | } | |
837 | ||
838 | /* The string str is prepended with the GDB printout token and sent. Required | |
839 | in traditional implementations. */ | |
840 | void | |
841 | putDebugString (const unsigned char *str, int length) | |
842 | { | |
843 | remcomOutBuffer[0] = 'O'; | |
844 | mem2hex(&remcomOutBuffer[1], (unsigned char *)str, length); | |
845 | putpacket(remcomOutBuffer); | |
846 | } | |
847 | ||
848 | /********************************** Handle exceptions ************************/ | |
849 | /* Build and send a response packet in order to inform the host the | |
850 | stub is stopped. TAAn...:r...;n...:r...;n...:r...; | |
851 | AA = signal number | |
852 | n... = register number (hex) | |
853 | r... = register contents | |
854 | n... = `thread' | |
855 | r... = thread process ID. This is a hex integer. | |
856 | n... = other string not starting with valid hex digit. | |
857 | gdb should ignore this n,r pair and go on to the next. | |
858 | This way we can extend the protocol. */ | |
859 | static void | |
860 | stub_is_stopped(int sigval) | |
861 | { | |
862 | char *ptr = remcomOutBuffer; | |
863 | int regno; | |
864 | ||
865 | unsigned int reg_cont; | |
866 | int status; | |
867 | ||
868 | /* Send trap type (converted to signal) */ | |
869 | ||
42a9a583 HH |
870 | *ptr++ = 'T'; |
871 | ptr = pack_hex_byte(ptr, sigval); | |
1da177e4 LT |
872 | |
873 | /* Send register contents. We probably only need to send the | |
874 | * PC, frame pointer and stack pointer here. Other registers will be | |
c03983ac | 875 | * explicitly asked for. But for now, send all. |
1da177e4 LT |
876 | */ |
877 | ||
878 | for (regno = R0; regno <= USP; regno++) { | |
879 | /* Store n...:r...; for the registers in the buffer. */ | |
880 | ||
881 | status = read_register (regno, ®_cont); | |
882 | ||
883 | if (status == SUCCESS) { | |
42a9a583 | 884 | ptr = pack_hex_byte(ptr, regno); |
1da177e4 LT |
885 | *ptr++ = ':'; |
886 | ||
887 | ptr = mem2hex(ptr, (unsigned char *)®_cont, | |
888 | register_size[regno]); | |
889 | *ptr++ = ';'; | |
890 | } | |
891 | ||
892 | } | |
893 | ||
894 | #ifdef PROCESS_SUPPORT | |
895 | /* Store the registers of the executing thread. Assume that both step, | |
896 | continue, and register content requests are with respect to this | |
897 | thread. The executing task is from the operating system scheduler. */ | |
898 | ||
899 | current_thread_c = executing_task; | |
900 | current_thread_g = executing_task; | |
901 | ||
902 | /* A struct assignment translates into a libc memcpy call. Avoid | |
903 | all libc functions in order to prevent recursive break points. */ | |
904 | copy_registers (®_g, ®, sizeof(registers)); | |
905 | ||
906 | /* Store thread:r...; with the executing task TID. */ | |
907 | gdb_cris_strcpy (&remcomOutBuffer[pos], "thread:"); | |
908 | pos += gdb_cris_strlen ("thread:"); | |
42a9a583 HH |
909 | remcomOutBuffer[pos++] = hex_asc_hi(executing_task); |
910 | remcomOutBuffer[pos++] = hex_asc_lo(executing_task); | |
1da177e4 LT |
911 | gdb_cris_strcpy (&remcomOutBuffer[pos], ";"); |
912 | #endif | |
913 | ||
914 | /* null-terminate and send it off */ | |
915 | ||
916 | *ptr = 0; | |
917 | ||
918 | putpacket (remcomOutBuffer); | |
919 | } | |
920 | ||
921 | /* All expected commands are sent from remote.c. Send a response according | |
922 | to the description in remote.c. */ | |
923 | static void | |
924 | handle_exception (int sigval) | |
925 | { | |
926 | /* Avoid warning of not used. */ | |
927 | ||
928 | USEDFUN(handle_exception); | |
929 | USEDVAR(internal_stack[0]); | |
930 | ||
931 | /* Send response. */ | |
932 | ||
933 | stub_is_stopped (sigval); | |
934 | ||
935 | for (;;) { | |
936 | remcomOutBuffer[0] = '\0'; | |
937 | getpacket (remcomInBuffer); | |
938 | switch (remcomInBuffer[0]) { | |
939 | case 'g': | |
940 | /* Read registers: g | |
941 | Success: Each byte of register data is described by two hex digits. | |
942 | Registers are in the internal order for GDB, and the bytes | |
943 | in a register are in the same order the machine uses. | |
944 | Failure: void. */ | |
945 | ||
946 | { | |
947 | #ifdef PROCESS_SUPPORT | |
948 | /* Use the special register content in the executing thread. */ | |
949 | copy_registers (®_g, ®, sizeof(registers)); | |
950 | /* Replace the content available on the stack. */ | |
951 | if (current_thread_g != executing_task) { | |
952 | copy_registers_from_stack (current_thread_g, ®_g); | |
953 | } | |
954 | mem2hex ((unsigned char *)remcomOutBuffer, (unsigned char *)®_g, sizeof(registers)); | |
955 | #else | |
956 | mem2hex(remcomOutBuffer, (char *)®, sizeof(registers)); | |
957 | #endif | |
958 | } | |
959 | break; | |
960 | ||
961 | case 'G': | |
962 | /* Write registers. GXX..XX | |
963 | Each byte of register data is described by two hex digits. | |
964 | Success: OK | |
965 | Failure: void. */ | |
966 | #ifdef PROCESS_SUPPORT | |
967 | hex2mem ((unsigned char *)®_g, &remcomInBuffer[1], sizeof(registers)); | |
968 | if (current_thread_g == executing_task) { | |
969 | copy_registers (®, ®_g, sizeof(registers)); | |
970 | } | |
971 | else { | |
972 | copy_registers_to_stack(current_thread_g, ®_g); | |
973 | } | |
974 | #else | |
975 | hex2mem((char *)®, &remcomInBuffer[1], sizeof(registers)); | |
976 | #endif | |
977 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
978 | break; | |
979 | ||
980 | case 'P': | |
981 | /* Write register. Pn...=r... | |
982 | Write register n..., hex value without 0x, with value r..., | |
983 | which contains a hex value without 0x and two hex digits | |
984 | for each byte in the register (target byte order). P1f=11223344 means | |
985 | set register 31 to 44332211. | |
986 | Success: OK | |
987 | Failure: E02, E05 */ | |
988 | { | |
989 | char *suffix; | |
990 | int regno = gdb_cris_strtol (&remcomInBuffer[1], &suffix, 16); | |
991 | int status; | |
992 | #ifdef PROCESS_SUPPORT | |
993 | if (current_thread_g != executing_task) | |
994 | status = write_stack_register (current_thread_g, regno, suffix+1); | |
995 | else | |
996 | #endif | |
997 | status = write_register (regno, suffix+1); | |
998 | ||
999 | switch (status) { | |
1000 | case E02: | |
1001 | /* Do not support read-only registers. */ | |
1002 | gdb_cris_strcpy (remcomOutBuffer, error_message[E02]); | |
1003 | break; | |
1004 | case E05: | |
1005 | /* Do not support non-existing registers. */ | |
1006 | gdb_cris_strcpy (remcomOutBuffer, error_message[E05]); | |
1007 | break; | |
1008 | case E07: | |
1009 | /* Do not support non-existing registers on the stack. */ | |
1010 | gdb_cris_strcpy (remcomOutBuffer, error_message[E07]); | |
1011 | break; | |
1012 | default: | |
1013 | /* Valid register number. */ | |
1014 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
1015 | break; | |
1016 | } | |
1017 | } | |
1018 | break; | |
1019 | ||
1020 | case 'm': | |
1021 | /* Read from memory. mAA..AA,LLLL | |
1022 | AA..AA is the address and LLLL is the length. | |
1023 | Success: XX..XX is the memory content. Can be fewer bytes than | |
1024 | requested if only part of the data may be read. m6000120a,6c means | |
1025 | retrieve 108 byte from base address 6000120a. | |
1026 | Failure: void. */ | |
1027 | { | |
1028 | char *suffix; | |
1029 | unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1], | |
1030 | &suffix, 16); int length = gdb_cris_strtol(suffix+1, 0, 16); | |
1031 | ||
1032 | mem2hex(remcomOutBuffer, addr, length); | |
1033 | } | |
1034 | break; | |
1035 | ||
1036 | case 'X': | |
1037 | /* Write to memory. XAA..AA,LLLL:XX..XX | |
1038 | AA..AA is the start address, LLLL is the number of bytes, and | |
1039 | XX..XX is the binary data. | |
1040 | Success: OK | |
1041 | Failure: void. */ | |
1042 | case 'M': | |
1043 | /* Write to memory. MAA..AA,LLLL:XX..XX | |
1044 | AA..AA is the start address, LLLL is the number of bytes, and | |
1045 | XX..XX is the hexadecimal data. | |
1046 | Success: OK | |
1047 | Failure: void. */ | |
1048 | { | |
1049 | char *lenptr; | |
1050 | char *dataptr; | |
1051 | unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1], | |
1052 | &lenptr, 16); | |
1053 | int length = gdb_cris_strtol(lenptr+1, &dataptr, 16); | |
1054 | if (*lenptr == ',' && *dataptr == ':') { | |
1055 | if (remcomInBuffer[0] == 'M') { | |
1056 | hex2mem(addr, dataptr + 1, length); | |
1057 | } | |
1058 | else /* X */ { | |
1059 | bin2mem(addr, dataptr + 1, length); | |
1060 | } | |
1061 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
1062 | } | |
1063 | else { | |
1064 | gdb_cris_strcpy (remcomOutBuffer, error_message[E06]); | |
1065 | } | |
1066 | } | |
1067 | break; | |
1068 | ||
1069 | case 'c': | |
1070 | /* Continue execution. cAA..AA | |
1071 | AA..AA is the address where execution is resumed. If AA..AA is | |
1072 | omitted, resume at the present address. | |
1073 | Success: return to the executing thread. | |
1074 | Failure: will never know. */ | |
1075 | if (remcomInBuffer[1] != '\0') { | |
1076 | reg.pc = gdb_cris_strtol (&remcomInBuffer[1], 0, 16); | |
1077 | } | |
1078 | enableDebugIRQ(); | |
1079 | return; | |
1080 | ||
1081 | case 's': | |
1082 | /* Step. sAA..AA | |
1083 | AA..AA is the address where execution is resumed. If AA..AA is | |
1084 | omitted, resume at the present address. Success: return to the | |
1085 | executing thread. Failure: will never know. | |
1086 | ||
1087 | Should never be invoked. The single-step is implemented on | |
1088 | the host side. If ever invoked, it is an internal error E04. */ | |
1089 | gdb_cris_strcpy (remcomOutBuffer, error_message[E04]); | |
1090 | putpacket (remcomOutBuffer); | |
1091 | return; | |
1092 | ||
1093 | case '?': | |
1094 | /* The last signal which caused a stop. ? | |
1095 | Success: SAA, where AA is the signal number. | |
1096 | Failure: void. */ | |
1097 | remcomOutBuffer[0] = 'S'; | |
42a9a583 HH |
1098 | remcomOutBuffer[1] = hex_asc_hi(sigval); |
1099 | remcomOutBuffer[2] = hex_asc_lo(sigval); | |
1da177e4 LT |
1100 | remcomOutBuffer[3] = 0; |
1101 | break; | |
1102 | ||
1103 | case 'D': | |
1104 | /* Detach from host. D | |
1105 | Success: OK, and return to the executing thread. | |
1106 | Failure: will never know */ | |
1107 | putpacket ("OK"); | |
1108 | return; | |
1109 | ||
1110 | case 'k': | |
1111 | case 'r': | |
1112 | /* kill request or reset request. | |
1113 | Success: restart of target. | |
1114 | Failure: will never know. */ | |
1115 | kill_restart (); | |
1116 | break; | |
1117 | ||
1118 | case 'C': | |
1119 | case 'S': | |
1120 | case '!': | |
1121 | case 'R': | |
1122 | case 'd': | |
1123 | /* Continue with signal sig. Csig;AA..AA | |
1124 | Step with signal sig. Ssig;AA..AA | |
1125 | Use the extended remote protocol. ! | |
1126 | Restart the target system. R0 | |
1127 | Toggle debug flag. d | |
1128 | Search backwards. tAA:PP,MM | |
1129 | Not supported: E04 */ | |
1130 | gdb_cris_strcpy (remcomOutBuffer, error_message[E04]); | |
1131 | break; | |
1132 | #ifdef PROCESS_SUPPORT | |
1133 | ||
1134 | case 'T': | |
1135 | /* Thread alive. TXX | |
1136 | Is thread XX alive? | |
1137 | Success: OK, thread XX is alive. | |
1138 | Failure: E03, thread XX is dead. */ | |
1139 | { | |
1140 | int thread_id = (int)gdb_cris_strtol (&remcomInBuffer[1], 0, 16); | |
1141 | /* Cannot tell whether it is alive or not. */ | |
1142 | if (thread_id >= 0 && thread_id < number_of_tasks) | |
1143 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
1144 | } | |
1145 | break; | |
1146 | ||
1147 | case 'H': | |
1148 | /* Set thread for subsequent operations: Hct | |
1149 | c = 'c' for thread used in step and continue; | |
1150 | t can be -1 for all threads. | |
1151 | c = 'g' for thread used in other operations. | |
1152 | t = 0 means pick any thread. | |
1153 | Success: OK | |
1154 | Failure: E01 */ | |
1155 | { | |
1156 | int thread_id = gdb_cris_strtol (&remcomInBuffer[2], 0, 16); | |
1157 | if (remcomInBuffer[1] == 'c') { | |
1158 | /* c = 'c' for thread used in step and continue */ | |
1159 | /* Do not change current_thread_c here. It would create a mess in | |
1160 | the scheduler. */ | |
1161 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
1162 | } | |
1163 | else if (remcomInBuffer[1] == 'g') { | |
1164 | /* c = 'g' for thread used in other operations. | |
1165 | t = 0 means pick any thread. Impossible since the scheduler does | |
1166 | not allow that. */ | |
1167 | if (thread_id >= 0 && thread_id < number_of_tasks) { | |
1168 | current_thread_g = thread_id; | |
1169 | gdb_cris_strcpy (remcomOutBuffer, "OK"); | |
1170 | } | |
1171 | else { | |
1172 | /* Not expected - send an error message. */ | |
1173 | gdb_cris_strcpy (remcomOutBuffer, error_message[E01]); | |
1174 | } | |
1175 | } | |
1176 | else { | |
1177 | /* Not expected - send an error message. */ | |
1178 | gdb_cris_strcpy (remcomOutBuffer, error_message[E01]); | |
1179 | } | |
1180 | } | |
1181 | break; | |
1182 | ||
1183 | case 'q': | |
1184 | case 'Q': | |
1185 | /* Query of general interest. qXXXX | |
1186 | Set general value XXXX. QXXXX=yyyy */ | |
1187 | { | |
1188 | int pos; | |
1189 | int nextpos; | |
1190 | int thread_id; | |
1191 | ||
1192 | switch (remcomInBuffer[1]) { | |
1193 | case 'C': | |
1194 | /* Identify the remote current thread. */ | |
1195 | gdb_cris_strcpy (&remcomOutBuffer[0], "QC"); | |
42a9a583 HH |
1196 | remcomOutBuffer[2] = hex_asc_hi(current_thread_c); |
1197 | remcomOutBuffer[3] = hex_asc_lo(current_thread_c); | |
1da177e4 LT |
1198 | remcomOutBuffer[4] = '\0'; |
1199 | break; | |
1200 | case 'L': | |
1201 | gdb_cris_strcpy (&remcomOutBuffer[0], "QM"); | |
1202 | /* Reply with number of threads. */ | |
1203 | if (os_is_started()) { | |
42a9a583 HH |
1204 | remcomOutBuffer[2] = hex_asc_hi(number_of_tasks); |
1205 | remcomOutBuffer[3] = hex_asc_lo(number_of_tasks); | |
1da177e4 LT |
1206 | } |
1207 | else { | |
42a9a583 HH |
1208 | remcomOutBuffer[2] = hex_asc_hi(0); |
1209 | remcomOutBuffer[3] = hex_asc_lo(1); | |
1da177e4 LT |
1210 | } |
1211 | /* Done with the reply. */ | |
42a9a583 | 1212 | remcomOutBuffer[4] = hex_asc_lo(1); |
1da177e4 LT |
1213 | pos = 5; |
1214 | /* Expects the argument thread id. */ | |
1215 | for (; pos < (5 + HEXCHARS_IN_THREAD_ID); pos++) | |
1216 | remcomOutBuffer[pos] = remcomInBuffer[pos]; | |
1217 | /* Reply with the thread identifiers. */ | |
1218 | if (os_is_started()) { | |
1219 | /* Store the thread identifiers of all tasks. */ | |
1220 | for (thread_id = 0; thread_id < number_of_tasks; thread_id++) { | |
1221 | nextpos = pos + HEXCHARS_IN_THREAD_ID - 1; | |
1222 | for (; pos < nextpos; pos ++) | |
42a9a583 HH |
1223 | remcomOutBuffer[pos] = hex_asc_lo(0); |
1224 | remcomOutBuffer[pos++] = hex_asc_lo(thread_id); | |
1da177e4 LT |
1225 | } |
1226 | } | |
1227 | else { | |
1228 | /* Store the thread identifier of the boot task. */ | |
1229 | nextpos = pos + HEXCHARS_IN_THREAD_ID - 1; | |
1230 | for (; pos < nextpos; pos ++) | |
42a9a583 HH |
1231 | remcomOutBuffer[pos] = hex_asc_lo(0); |
1232 | remcomOutBuffer[pos++] = hex_asc_lo(current_thread_c); | |
1da177e4 LT |
1233 | } |
1234 | remcomOutBuffer[pos] = '\0'; | |
1235 | break; | |
1236 | default: | |
1237 | /* Not supported: "" */ | |
1238 | /* Request information about section offsets: qOffsets. */ | |
1239 | remcomOutBuffer[0] = 0; | |
1240 | break; | |
1241 | } | |
1242 | } | |
1243 | break; | |
1244 | #endif /* PROCESS_SUPPORT */ | |
1245 | ||
1246 | default: | |
1247 | /* The stub should ignore other request and send an empty | |
1248 | response ($#<checksum>). This way we can extend the protocol and GDB | |
1249 | can tell whether the stub it is talking to uses the old or the new. */ | |
1250 | remcomOutBuffer[0] = 0; | |
1251 | break; | |
1252 | } | |
1253 | putpacket(remcomOutBuffer); | |
1254 | } | |
1255 | } | |
1256 | ||
7cf32cad | 1257 | /* Performs a complete re-start from scratch. */ |
1da177e4 LT |
1258 | static void |
1259 | kill_restart () | |
1260 | { | |
7cf32cad | 1261 | machine_restart(""); |
1da177e4 LT |
1262 | } |
1263 | ||
1264 | /********************************** Breakpoint *******************************/ | |
1265 | /* The hook for both a static (compiled) and a dynamic breakpoint set by GDB. | |
1266 | An internal stack is used by the stub. The register image of the caller is | |
1267 | stored in the structure register_image. | |
1268 | Interactive communication with the host is handled by handle_exception and | |
1269 | finally the register image is restored. */ | |
1270 | ||
1271 | void kgdb_handle_breakpoint(void); | |
1272 | ||
1273 | asm (" | |
1274 | .global kgdb_handle_breakpoint | |
1275 | kgdb_handle_breakpoint: | |
1276 | ;; | |
1277 | ;; Response to the break-instruction | |
1278 | ;; | |
1279 | ;; Create a register image of the caller | |
1280 | ;; | |
1281 | move $dccr,[reg+0x5E] ; Save the flags in DCCR before disable interrupts | |
1282 | di ; Disable interrupts | |
1283 | move.d $r0,[reg] ; Save R0 | |
1284 | move.d $r1,[reg+0x04] ; Save R1 | |
1285 | move.d $r2,[reg+0x08] ; Save R2 | |
1286 | move.d $r3,[reg+0x0C] ; Save R3 | |
1287 | move.d $r4,[reg+0x10] ; Save R4 | |
1288 | move.d $r5,[reg+0x14] ; Save R5 | |
1289 | move.d $r6,[reg+0x18] ; Save R6 | |
1290 | move.d $r7,[reg+0x1C] ; Save R7 | |
1291 | move.d $r8,[reg+0x20] ; Save R8 | |
1292 | move.d $r9,[reg+0x24] ; Save R9 | |
1293 | move.d $r10,[reg+0x28] ; Save R10 | |
1294 | move.d $r11,[reg+0x2C] ; Save R11 | |
1295 | move.d $r12,[reg+0x30] ; Save R12 | |
1296 | move.d $r13,[reg+0x34] ; Save R13 | |
1297 | move.d $sp,[reg+0x38] ; Save SP (R14) | |
1298 | ;; Due to the old assembler-versions BRP might not be recognized | |
1299 | .word 0xE670 ; move brp,$r0 | |
1300 | subq 2,$r0 ; Set to address of previous instruction. | |
1301 | move.d $r0,[reg+0x3c] ; Save the address in PC (R15) | |
1302 | clear.b [reg+0x40] ; Clear P0 | |
1303 | move $vr,[reg+0x41] ; Save special register P1 | |
1304 | clear.w [reg+0x42] ; Clear P4 | |
1305 | move $ccr,[reg+0x44] ; Save special register CCR | |
1306 | move $mof,[reg+0x46] ; P7 | |
1307 | clear.d [reg+0x4A] ; Clear P8 | |
1308 | move $ibr,[reg+0x4E] ; P9, | |
1309 | move $irp,[reg+0x52] ; P10, | |
1310 | move $srp,[reg+0x56] ; P11, | |
1311 | move $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR | |
1312 | ; P13, register DCCR already saved | |
1313 | ;; Due to the old assembler-versions BRP might not be recognized | |
1314 | .word 0xE670 ; move brp,r0 | |
1315 | ;; Static (compiled) breakpoints must return to the next instruction in order | |
1316 | ;; to avoid infinite loops. Dynamic (gdb-invoked) must restore the instruction | |
1317 | ;; in order to execute it when execution is continued. | |
1318 | test.b [is_dyn_brkp] ; Is this a dynamic breakpoint? | |
1319 | beq is_static ; No, a static breakpoint | |
1320 | nop | |
1321 | subq 2,$r0 ; rerun the instruction the break replaced | |
1322 | is_static: | |
1323 | moveq 1,$r1 | |
1324 | move.b $r1,[is_dyn_brkp] ; Set the state variable to dynamic breakpoint | |
1325 | move.d $r0,[reg+0x62] ; Save the return address in BRP | |
1326 | move $usp,[reg+0x66] ; USP | |
1327 | ;; | |
1328 | ;; Handle the communication | |
1329 | ;; | |
1330 | move.d internal_stack+1020,$sp ; Use the internal stack which grows upward | |
1331 | moveq 5,$r10 ; SIGTRAP | |
1332 | jsr handle_exception ; Interactive routine | |
1333 | ;; | |
1334 | ;; Return to the caller | |
1335 | ;; | |
1336 | move.d [reg],$r0 ; Restore R0 | |
1337 | move.d [reg+0x04],$r1 ; Restore R1 | |
1338 | move.d [reg+0x08],$r2 ; Restore R2 | |
1339 | move.d [reg+0x0C],$r3 ; Restore R3 | |
1340 | move.d [reg+0x10],$r4 ; Restore R4 | |
1341 | move.d [reg+0x14],$r5 ; Restore R5 | |
1342 | move.d [reg+0x18],$r6 ; Restore R6 | |
1343 | move.d [reg+0x1C],$r7 ; Restore R7 | |
1344 | move.d [reg+0x20],$r8 ; Restore R8 | |
1345 | move.d [reg+0x24],$r9 ; Restore R9 | |
1346 | move.d [reg+0x28],$r10 ; Restore R10 | |
1347 | move.d [reg+0x2C],$r11 ; Restore R11 | |
1348 | move.d [reg+0x30],$r12 ; Restore R12 | |
1349 | move.d [reg+0x34],$r13 ; Restore R13 | |
1350 | ;; | |
1351 | ;; FIXME: Which registers should be restored? | |
1352 | ;; | |
1353 | move.d [reg+0x38],$sp ; Restore SP (R14) | |
1354 | move [reg+0x56],$srp ; Restore the subroutine return pointer. | |
1355 | move [reg+0x5E],$dccr ; Restore DCCR | |
1356 | move [reg+0x66],$usp ; Restore USP | |
1357 | jump [reg+0x62] ; A jump to the content in register BRP works. | |
1358 | nop ; | |
1359 | "); | |
1360 | ||
1361 | /* The hook for an interrupt generated by GDB. An internal stack is used | |
1362 | by the stub. The register image of the caller is stored in the structure | |
1363 | register_image. Interactive communication with the host is handled by | |
1364 | handle_exception and finally the register image is restored. Due to the | |
1365 | old assembler which does not recognise the break instruction and the | |
1366 | breakpoint return pointer hex-code is used. */ | |
1367 | ||
1368 | void kgdb_handle_serial(void); | |
1369 | ||
1370 | asm (" | |
1371 | .global kgdb_handle_serial | |
1372 | kgdb_handle_serial: | |
1373 | ;; | |
1374 | ;; Response to a serial interrupt | |
1375 | ;; | |
1376 | ||
1377 | move $dccr,[reg+0x5E] ; Save the flags in DCCR | |
1378 | di ; Disable interrupts | |
1379 | move.d $r0,[reg] ; Save R0 | |
1380 | move.d $r1,[reg+0x04] ; Save R1 | |
1381 | move.d $r2,[reg+0x08] ; Save R2 | |
1382 | move.d $r3,[reg+0x0C] ; Save R3 | |
1383 | move.d $r4,[reg+0x10] ; Save R4 | |
1384 | move.d $r5,[reg+0x14] ; Save R5 | |
1385 | move.d $r6,[reg+0x18] ; Save R6 | |
1386 | move.d $r7,[reg+0x1C] ; Save R7 | |
1387 | move.d $r8,[reg+0x20] ; Save R8 | |
1388 | move.d $r9,[reg+0x24] ; Save R9 | |
1389 | move.d $r10,[reg+0x28] ; Save R10 | |
1390 | move.d $r11,[reg+0x2C] ; Save R11 | |
1391 | move.d $r12,[reg+0x30] ; Save R12 | |
1392 | move.d $r13,[reg+0x34] ; Save R13 | |
1393 | move.d $sp,[reg+0x38] ; Save SP (R14) | |
1394 | move $irp,[reg+0x3c] ; Save the address in PC (R15) | |
1395 | clear.b [reg+0x40] ; Clear P0 | |
1396 | move $vr,[reg+0x41] ; Save special register P1, | |
1397 | clear.w [reg+0x42] ; Clear P4 | |
1398 | move $ccr,[reg+0x44] ; Save special register CCR | |
1399 | move $mof,[reg+0x46] ; P7 | |
1400 | clear.d [reg+0x4A] ; Clear P8 | |
1401 | move $ibr,[reg+0x4E] ; P9, | |
1402 | move $irp,[reg+0x52] ; P10, | |
1403 | move $srp,[reg+0x56] ; P11, | |
1404 | move $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR | |
1405 | ; P13, register DCCR already saved | |
1406 | ;; Due to the old assembler-versions BRP might not be recognized | |
1407 | .word 0xE670 ; move brp,r0 | |
1408 | move.d $r0,[reg+0x62] ; Save the return address in BRP | |
1409 | move $usp,[reg+0x66] ; USP | |
1410 | ||
1411 | ;; get the serial character (from debugport.c) and check if it is a ctrl-c | |
1412 | ||
1413 | jsr getDebugChar | |
1414 | cmp.b 3, $r10 | |
1415 | bne goback | |
1416 | nop | |
1417 | ||
7cf32cad MS |
1418 | move.d [reg+0x5E], $r10 ; Get DCCR |
1419 | btstq 8, $r10 ; Test the U-flag. | |
1420 | bmi goback | |
1421 | nop | |
1422 | ||
1da177e4 LT |
1423 | ;; |
1424 | ;; Handle the communication | |
1425 | ;; | |
1426 | move.d internal_stack+1020,$sp ; Use the internal stack | |
1427 | moveq 2,$r10 ; SIGINT | |
1428 | jsr handle_exception ; Interactive routine | |
1429 | ||
1430 | goback: | |
1431 | ;; | |
1432 | ;; Return to the caller | |
1433 | ;; | |
1434 | move.d [reg],$r0 ; Restore R0 | |
1435 | move.d [reg+0x04],$r1 ; Restore R1 | |
1436 | move.d [reg+0x08],$r2 ; Restore R2 | |
1437 | move.d [reg+0x0C],$r3 ; Restore R3 | |
1438 | move.d [reg+0x10],$r4 ; Restore R4 | |
1439 | move.d [reg+0x14],$r5 ; Restore R5 | |
1440 | move.d [reg+0x18],$r6 ; Restore R6 | |
1441 | move.d [reg+0x1C],$r7 ; Restore R7 | |
1442 | move.d [reg+0x20],$r8 ; Restore R8 | |
1443 | move.d [reg+0x24],$r9 ; Restore R9 | |
1444 | move.d [reg+0x28],$r10 ; Restore R10 | |
1445 | move.d [reg+0x2C],$r11 ; Restore R11 | |
1446 | move.d [reg+0x30],$r12 ; Restore R12 | |
1447 | move.d [reg+0x34],$r13 ; Restore R13 | |
1448 | ;; | |
1449 | ;; FIXME: Which registers should be restored? | |
1450 | ;; | |
1451 | move.d [reg+0x38],$sp ; Restore SP (R14) | |
1452 | move [reg+0x56],$srp ; Restore the subroutine return pointer. | |
1453 | move [reg+0x5E],$dccr ; Restore DCCR | |
1454 | move [reg+0x66],$usp ; Restore USP | |
1455 | reti ; Return from the interrupt routine | |
1456 | nop | |
1457 | "); | |
1458 | ||
1459 | /* Use this static breakpoint in the start-up only. */ | |
1460 | ||
1461 | void | |
1462 | breakpoint(void) | |
1463 | { | |
1464 | kgdb_started = 1; | |
1465 | is_dyn_brkp = 0; /* This is a static, not a dynamic breakpoint. */ | |
1466 | __asm__ volatile ("break 8"); /* Jump to handle_breakpoint. */ | |
1467 | } | |
1468 | ||
1469 | /* initialize kgdb. doesn't break into the debugger, but sets up irq and ports */ | |
1470 | ||
1471 | void | |
1472 | kgdb_init(void) | |
1473 | { | |
1474 | /* could initialize debug port as well but it's done in head.S already... */ | |
1475 | ||
1476 | /* breakpoint handler is now set in irq.c */ | |
1477 | set_int_vector(8, kgdb_handle_serial); | |
1478 | ||
1479 | enableDebugIRQ(); | |
1480 | } | |
1481 | ||
1482 | /****************************** End of file **********************************/ |