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