ia64/linux-2.6.18-xen.hg

view arch/cris/arch-v10/kernel/kgdb.c @ 647:a5bb490065f6

Fix the build after public header sync.
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Wed Aug 13 14:01:49 2008 +0100 (2008-08-13)
parents 831230e53067
children
line source
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 */
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 */
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 */
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>
234 #include <asm/setup.h>
235 #include <asm/ptrace.h>
237 #include <asm/arch/svinto.h>
238 #include <asm/irq.h>
240 static int kgdb_started = 0;
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. */
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 */
273 unsigned char p0; /* 0x40 8-bit zero-register */
274 unsigned char vr; /* 0x41 Version register */
276 unsigned short p4; /* 0x42 16-bit zero-register */
277 unsigned short ccr; /* 0x44 Condition code register */
279 unsigned int mof; /* 0x46 Multiply overflow register */
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;
291 /************** Prototypes for local library functions ***********************/
293 /* Copy of strcpy from libc. */
294 static char *gdb_cris_strcpy (char *s1, const char *s2);
296 /* Copy of strlen from libc. */
297 static int gdb_cris_strlen (const char *s);
299 /* Copy of memchr from libc. */
300 static void *gdb_cris_memchr (const void *s, int c, int n);
302 /* Copy of strtol from libc. Does only support base 16. */
303 static int gdb_cris_strtol (const char *s, char **endptr, int base);
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);
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);
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);
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);
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);
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);
331 /* Serial port, reads one character. ETRAX 100 specific. from debugport.c */
332 int getDebugChar (void);
334 /* Serial port, writes one character. ETRAX 100 specific. from debugport.c */
335 void putDebugChar (int val);
337 void enableDebugIRQ (void);
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);
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);
347 /* Returns the integer equivalent of a hexadecimal character. */
348 static int hex (char ch);
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);
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);
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);
365 /* Await the sequence $<data>#<checksum> and store <data> in the array buffer
366 returned. */
367 static void getpacket (char *buffer);
369 /* Send $<data>#<checksum> from the <data> in the array buffer. */
370 static void putpacket (char *buffer);
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);
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);
380 /* Performs a complete re-start from scratch. ETRAX specific. */
381 static void kill_restart (void);
383 /******************** Prototypes for global functions. ***********************/
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 */
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 */
392 /* The hook for an interrupt generated by GDB. ETRAX 100 specific. */
393 void handle_interrupt (void); /* used by irq.c */
395 /* A static breakpoint to be used at startup. */
396 void breakpoint (void); /* called by init/main.c */
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;
402 /* The number of characters used for a 64 bit thread identifier. */
403 #define HEXCHARS_IN_THREAD_ID 16
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) }
409 /********************************** Packet I/O ******************************/
410 /* BUFMAX defines the maximum number of characters in
411 inbound/outbound buffers */
412 #define BUFMAX 512
414 /* Run-length encoding maximum length. Send 64 at most. */
415 #define RUNLENMAX 64
417 /* Definition of all valid hexadecimal characters */
418 static const char hexchars[] = "0123456789abcdef";
420 /* The inbound/outbound buffers used in packet I/O */
421 static char remcomInBuffer[BUFMAX];
422 static char remcomOutBuffer[BUFMAX];
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 };
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 };
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;
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;
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 */
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;
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;
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];
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;
513 /********************************* String library ****************************/
514 /* Single-step over library functions creates trap loops. */
516 /* Copy char s2[] to s1[]. */
517 static char*
518 gdb_cris_strcpy (char *s1, const char *s2)
519 {
520 char *s = s1;
522 for (s = s1; (*s++ = *s2++) != '\0'; )
523 ;
524 return (s1);
525 }
527 /* Find length of s[]. */
528 static int
529 gdb_cris_strlen (const char *s)
530 {
531 const char *sc;
533 for (sc = s; *sc != '\0'; sc++)
534 ;
535 return (sc - s);
536 }
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;
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;
560 for (s1 = (char*)s; (sd = gdb_cris_memchr(hexchars, *s1, base)) != NULL; ++s1)
561 x = x * base + (sd - hexchars);
563 if (endptr)
564 {
565 /* Unconverted suffix is stored in endptr unless endptr is NULL. */
566 *endptr = s1;
567 }
569 return x;
570 }
572 /********************************* Register image ****************************/
573 /* Copy the content of a register image into another. The size n is
574 the size of the register image. Due to struct assignment generation of
575 memcpy in libc. */
576 static void
577 copy_registers (registers *dptr, registers *sptr, int n)
578 {
579 unsigned char *dreg;
580 unsigned char *sreg;
582 for (dreg = (unsigned char*)dptr, sreg = (unsigned char*)sptr; n > 0; n--)
583 *dreg++ = *sreg++;
584 }
586 #ifdef PROCESS_SUPPORT
587 /* Copy the stored registers from the stack. Put the register contents
588 of thread thread_id in the struct reg. */
589 static void
590 copy_registers_from_stack (int thread_id, registers *regptr)
591 {
592 int j;
593 stack_registers *s = (stack_registers *)stack_list[thread_id];
594 unsigned int *d = (unsigned int *)regptr;
596 for (j = 13; j >= 0; j--)
597 *d++ = s->r[j];
598 regptr->sp = (unsigned int)stack_list[thread_id];
599 regptr->pc = s->pc;
600 regptr->dccr = s->dccr;
601 regptr->srp = s->srp;
602 }
604 /* Copy the registers to the stack. Put the register contents of thread
605 thread_id from struct reg to the stack. */
606 static void
607 copy_registers_to_stack (int thread_id, registers *regptr)
608 {
609 int i;
610 stack_registers *d = (stack_registers *)stack_list[thread_id];
611 unsigned int *s = (unsigned int *)regptr;
613 for (i = 0; i < 14; i++) {
614 d->r[i] = *s++;
615 }
616 d->pc = regptr->pc;
617 d->dccr = regptr->dccr;
618 d->srp = regptr->srp;
619 }
620 #endif
622 /* Write a value to a specified register in the register image of the current
623 thread. Returns status code SUCCESS, E02 or E05. */
624 static int
625 write_register (int regno, char *val)
626 {
627 int status = SUCCESS;
628 registers *current_reg = &reg;
630 if (regno >= R0 && regno <= PC) {
631 /* 32-bit register with simple offset. */
632 hex2mem ((unsigned char *)current_reg + regno * sizeof(unsigned int),
633 val, sizeof(unsigned int));
634 }
635 else if (regno == P0 || regno == VR || regno == P4 || regno == P8) {
636 /* Do not support read-only registers. */
637 status = E02;
638 }
639 else if (regno == CCR) {
640 /* 16 bit register with complex offset. (P4 is read-only, P6 is not implemented,
641 and P7 (MOF) is 32 bits in ETRAX 100LX. */
642 hex2mem ((unsigned char *)&(current_reg->ccr) + (regno-CCR) * sizeof(unsigned short),
643 val, sizeof(unsigned short));
644 }
645 else if (regno >= MOF && regno <= USP) {
646 /* 32 bit register with complex offset. (P8 has been taken care of.) */
647 hex2mem ((unsigned char *)&(current_reg->ibr) + (regno-IBR) * sizeof(unsigned int),
648 val, sizeof(unsigned int));
649 }
650 else {
651 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
652 status = E05;
653 }
654 return status;
655 }
657 #ifdef PROCESS_SUPPORT
658 /* Write a value to a specified register in the stack of a thread other
659 than the current thread. Returns status code SUCCESS or E07. */
660 static int
661 write_stack_register (int thread_id, int regno, char *valptr)
662 {
663 int status = SUCCESS;
664 stack_registers *d = (stack_registers *)stack_list[thread_id];
665 unsigned int val;
667 hex2mem ((unsigned char *)&val, valptr, sizeof(unsigned int));
668 if (regno >= R0 && regno < SP) {
669 d->r[regno] = val;
670 }
671 else if (regno == SP) {
672 stack_list[thread_id] = val;
673 }
674 else if (regno == PC) {
675 d->pc = val;
676 }
677 else if (regno == SRP) {
678 d->srp = val;
679 }
680 else if (regno == DCCR) {
681 d->dccr = val;
682 }
683 else {
684 /* Do not support registers in the current thread. */
685 status = E07;
686 }
687 return status;
688 }
689 #endif
691 /* Read a value from a specified register in the register image. Returns the
692 value in the register or -1 for non-implemented registers.
693 Should check consistency_status after a call which may be E05 after changes
694 in the implementation. */
695 static int
696 read_register (char regno, unsigned int *valptr)
697 {
698 registers *current_reg = &reg;
700 if (regno >= R0 && regno <= PC) {
701 /* 32-bit register with simple offset. */
702 *valptr = *(unsigned int *)((char *)current_reg + regno * sizeof(unsigned int));
703 return SUCCESS;
704 }
705 else if (regno == P0 || regno == VR) {
706 /* 8 bit register with complex offset. */
707 *valptr = (unsigned int)(*(unsigned char *)
708 ((char *)&(current_reg->p0) + (regno-P0) * sizeof(char)));
709 return SUCCESS;
710 }
711 else if (regno == P4 || regno == CCR) {
712 /* 16 bit register with complex offset. */
713 *valptr = (unsigned int)(*(unsigned short *)
714 ((char *)&(current_reg->p4) + (regno-P4) * sizeof(unsigned short)));
715 return SUCCESS;
716 }
717 else if (regno >= MOF && regno <= USP) {
718 /* 32 bit register with complex offset. */
719 *valptr = *(unsigned int *)((char *)&(current_reg->p8)
720 + (regno-P8) * sizeof(unsigned int));
721 return SUCCESS;
722 }
723 else {
724 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
725 consistency_status = E05;
726 return E05;
727 }
728 }
730 /********************************** Packet I/O ******************************/
731 /* Returns the character equivalent of a nibble, bit 7, 6, 5, and 4 of a byte,
732 represented by int x. */
733 static inline char
734 highhex(int x)
735 {
736 return hexchars[(x >> 4) & 0xf];
737 }
739 /* Returns the character equivalent of a nibble, bit 3, 2, 1, and 0 of a byte,
740 represented by int x. */
741 static inline char
742 lowhex(int x)
743 {
744 return hexchars[x & 0xf];
745 }
747 /* Returns the integer equivalent of a hexadecimal character. */
748 static int
749 hex (char ch)
750 {
751 if ((ch >= 'a') && (ch <= 'f'))
752 return (ch - 'a' + 10);
753 if ((ch >= '0') && (ch <= '9'))
754 return (ch - '0');
755 if ((ch >= 'A') && (ch <= 'F'))
756 return (ch - 'A' + 10);
757 return (-1);
758 }
760 /* Convert the memory, pointed to by mem into hexadecimal representation.
761 Put the result in buf, and return a pointer to the last character
762 in buf (null). */
764 static int do_printk = 0;
766 static char *
767 mem2hex(char *buf, unsigned char *mem, int count)
768 {
769 int i;
770 int ch;
772 if (mem == NULL) {
773 /* Bogus read from m0. FIXME: What constitutes a valid address? */
774 for (i = 0; i < count; i++) {
775 *buf++ = '0';
776 *buf++ = '0';
777 }
778 } else {
779 /* Valid mem address. */
780 for (i = 0; i < count; i++) {
781 ch = *mem++;
782 *buf++ = highhex (ch);
783 *buf++ = lowhex (ch);
784 }
785 }
787 /* Terminate properly. */
788 *buf = '\0';
789 return (buf);
790 }
792 /* Convert the array, in hexadecimal representation, pointed to by buf into
793 binary representation. Put the result in mem, and return a pointer to
794 the character after the last byte written. */
795 static unsigned char*
796 hex2mem (unsigned char *mem, char *buf, int count)
797 {
798 int i;
799 unsigned char ch;
800 for (i = 0; i < count; i++) {
801 ch = hex (*buf++) << 4;
802 ch = ch + hex (*buf++);
803 *mem++ = ch;
804 }
805 return (mem);
806 }
808 /* Put the content of the array, in binary representation, pointed to by buf
809 into memory pointed to by mem, and return a pointer to the character after
810 the last byte written.
811 Gdb will escape $, #, and the escape char (0x7d). */
812 static unsigned char*
813 bin2mem (unsigned char *mem, unsigned char *buf, int count)
814 {
815 int i;
816 unsigned char *next;
817 for (i = 0; i < count; i++) {
818 /* Check for any escaped characters. Be paranoid and
819 only unescape chars that should be escaped. */
820 if (*buf == 0x7d) {
821 next = buf + 1;
822 if (*next == 0x3 || *next == 0x4 || *next == 0x5D) /* #, $, ESC */
823 {
824 buf++;
825 *buf += 0x20;
826 }
827 }
828 *mem++ = *buf++;
829 }
830 return (mem);
831 }
833 /* Await the sequence $<data>#<checksum> and store <data> in the array buffer
834 returned. */
835 static void
836 getpacket (char *buffer)
837 {
838 unsigned char checksum;
839 unsigned char xmitcsum;
840 int i;
841 int count;
842 char ch;
843 do {
844 while ((ch = getDebugChar ()) != '$')
845 /* Wait for the start character $ and ignore all other characters */;
846 checksum = 0;
847 xmitcsum = -1;
848 count = 0;
849 /* Read until a # or the end of the buffer is reached */
850 while (count < BUFMAX) {
851 ch = getDebugChar ();
852 if (ch == '#')
853 break;
854 checksum = checksum + ch;
855 buffer[count] = ch;
856 count = count + 1;
857 }
858 buffer[count] = '\0';
860 if (ch == '#') {
861 xmitcsum = hex (getDebugChar ()) << 4;
862 xmitcsum += hex (getDebugChar ());
863 if (checksum != xmitcsum) {
864 /* Wrong checksum */
865 putDebugChar ('-');
866 }
867 else {
868 /* Correct checksum */
869 putDebugChar ('+');
870 /* If sequence characters are received, reply with them */
871 if (buffer[2] == ':') {
872 putDebugChar (buffer[0]);
873 putDebugChar (buffer[1]);
874 /* Remove the sequence characters from the buffer */
875 count = gdb_cris_strlen (buffer);
876 for (i = 3; i <= count; i++)
877 buffer[i - 3] = buffer[i];
878 }
879 }
880 }
881 } while (checksum != xmitcsum);
882 }
884 /* Send $<data>#<checksum> from the <data> in the array buffer. */
886 static void
887 putpacket(char *buffer)
888 {
889 int checksum;
890 int runlen;
891 int encode;
893 do {
894 char *src = buffer;
895 putDebugChar ('$');
896 checksum = 0;
897 while (*src) {
898 /* Do run length encoding */
899 putDebugChar (*src);
900 checksum += *src;
901 runlen = 0;
902 while (runlen < RUNLENMAX && *src == src[runlen]) {
903 runlen++;
904 }
905 if (runlen > 3) {
906 /* Got a useful amount */
907 putDebugChar ('*');
908 checksum += '*';
909 encode = runlen + ' ' - 4;
910 putDebugChar (encode);
911 checksum += encode;
912 src += runlen;
913 }
914 else {
915 src++;
916 }
917 }
918 putDebugChar ('#');
919 putDebugChar (highhex (checksum));
920 putDebugChar (lowhex (checksum));
921 } while(kgdb_started && (getDebugChar() != '+'));
922 }
924 /* The string str is prepended with the GDB printout token and sent. Required
925 in traditional implementations. */
926 void
927 putDebugString (const unsigned char *str, int length)
928 {
929 remcomOutBuffer[0] = 'O';
930 mem2hex(&remcomOutBuffer[1], (unsigned char *)str, length);
931 putpacket(remcomOutBuffer);
932 }
934 /********************************** Handle exceptions ************************/
935 /* Build and send a response packet in order to inform the host the
936 stub is stopped. TAAn...:r...;n...:r...;n...:r...;
937 AA = signal number
938 n... = register number (hex)
939 r... = register contents
940 n... = `thread'
941 r... = thread process ID. This is a hex integer.
942 n... = other string not starting with valid hex digit.
943 gdb should ignore this n,r pair and go on to the next.
944 This way we can extend the protocol. */
945 static void
946 stub_is_stopped(int sigval)
947 {
948 char *ptr = remcomOutBuffer;
949 int regno;
951 unsigned int reg_cont;
952 int status;
954 /* Send trap type (converted to signal) */
956 *ptr++ = 'T';
957 *ptr++ = highhex (sigval);
958 *ptr++ = lowhex (sigval);
960 /* Send register contents. We probably only need to send the
961 * PC, frame pointer and stack pointer here. Other registers will be
962 * explicitely asked for. But for now, send all.
963 */
965 for (regno = R0; regno <= USP; regno++) {
966 /* Store n...:r...; for the registers in the buffer. */
968 status = read_register (regno, &reg_cont);
970 if (status == SUCCESS) {
972 *ptr++ = highhex (regno);
973 *ptr++ = lowhex (regno);
974 *ptr++ = ':';
976 ptr = mem2hex(ptr, (unsigned char *)&reg_cont,
977 register_size[regno]);
978 *ptr++ = ';';
979 }
981 }
983 #ifdef PROCESS_SUPPORT
984 /* Store the registers of the executing thread. Assume that both step,
985 continue, and register content requests are with respect to this
986 thread. The executing task is from the operating system scheduler. */
988 current_thread_c = executing_task;
989 current_thread_g = executing_task;
991 /* A struct assignment translates into a libc memcpy call. Avoid
992 all libc functions in order to prevent recursive break points. */
993 copy_registers (&reg_g, &reg, sizeof(registers));
995 /* Store thread:r...; with the executing task TID. */
996 gdb_cris_strcpy (&remcomOutBuffer[pos], "thread:");
997 pos += gdb_cris_strlen ("thread:");
998 remcomOutBuffer[pos++] = highhex (executing_task);
999 remcomOutBuffer[pos++] = lowhex (executing_task);
1000 gdb_cris_strcpy (&remcomOutBuffer[pos], ";");
1001 #endif
1003 /* null-terminate and send it off */
1005 *ptr = 0;
1007 putpacket (remcomOutBuffer);
1010 /* All expected commands are sent from remote.c. Send a response according
1011 to the description in remote.c. */
1012 static void
1013 handle_exception (int sigval)
1015 /* Avoid warning of not used. */
1017 USEDFUN(handle_exception);
1018 USEDVAR(internal_stack[0]);
1020 /* Send response. */
1022 stub_is_stopped (sigval);
1024 for (;;) {
1025 remcomOutBuffer[0] = '\0';
1026 getpacket (remcomInBuffer);
1027 switch (remcomInBuffer[0]) {
1028 case 'g':
1029 /* Read registers: g
1030 Success: Each byte of register data is described by two hex digits.
1031 Registers are in the internal order for GDB, and the bytes
1032 in a register are in the same order the machine uses.
1033 Failure: void. */
1036 #ifdef PROCESS_SUPPORT
1037 /* Use the special register content in the executing thread. */
1038 copy_registers (&reg_g, &reg, sizeof(registers));
1039 /* Replace the content available on the stack. */
1040 if (current_thread_g != executing_task) {
1041 copy_registers_from_stack (current_thread_g, &reg_g);
1043 mem2hex ((unsigned char *)remcomOutBuffer, (unsigned char *)&reg_g, sizeof(registers));
1044 #else
1045 mem2hex(remcomOutBuffer, (char *)&reg, sizeof(registers));
1046 #endif
1048 break;
1050 case 'G':
1051 /* Write registers. GXX..XX
1052 Each byte of register data is described by two hex digits.
1053 Success: OK
1054 Failure: void. */
1055 #ifdef PROCESS_SUPPORT
1056 hex2mem ((unsigned char *)&reg_g, &remcomInBuffer[1], sizeof(registers));
1057 if (current_thread_g == executing_task) {
1058 copy_registers (&reg, &reg_g, sizeof(registers));
1060 else {
1061 copy_registers_to_stack(current_thread_g, &reg_g);
1063 #else
1064 hex2mem((char *)&reg, &remcomInBuffer[1], sizeof(registers));
1065 #endif
1066 gdb_cris_strcpy (remcomOutBuffer, "OK");
1067 break;
1069 case 'P':
1070 /* Write register. Pn...=r...
1071 Write register n..., hex value without 0x, with value r...,
1072 which contains a hex value without 0x and two hex digits
1073 for each byte in the register (target byte order). P1f=11223344 means
1074 set register 31 to 44332211.
1075 Success: OK
1076 Failure: E02, E05 */
1078 char *suffix;
1079 int regno = gdb_cris_strtol (&remcomInBuffer[1], &suffix, 16);
1080 int status;
1081 #ifdef PROCESS_SUPPORT
1082 if (current_thread_g != executing_task)
1083 status = write_stack_register (current_thread_g, regno, suffix+1);
1084 else
1085 #endif
1086 status = write_register (regno, suffix+1);
1088 switch (status) {
1089 case E02:
1090 /* Do not support read-only registers. */
1091 gdb_cris_strcpy (remcomOutBuffer, error_message[E02]);
1092 break;
1093 case E05:
1094 /* Do not support non-existing registers. */
1095 gdb_cris_strcpy (remcomOutBuffer, error_message[E05]);
1096 break;
1097 case E07:
1098 /* Do not support non-existing registers on the stack. */
1099 gdb_cris_strcpy (remcomOutBuffer, error_message[E07]);
1100 break;
1101 default:
1102 /* Valid register number. */
1103 gdb_cris_strcpy (remcomOutBuffer, "OK");
1104 break;
1107 break;
1109 case 'm':
1110 /* Read from memory. mAA..AA,LLLL
1111 AA..AA is the address and LLLL is the length.
1112 Success: XX..XX is the memory content. Can be fewer bytes than
1113 requested if only part of the data may be read. m6000120a,6c means
1114 retrieve 108 byte from base address 6000120a.
1115 Failure: void. */
1117 char *suffix;
1118 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
1119 &suffix, 16); int length = gdb_cris_strtol(suffix+1, 0, 16);
1121 mem2hex(remcomOutBuffer, addr, length);
1123 break;
1125 case 'X':
1126 /* Write to memory. XAA..AA,LLLL:XX..XX
1127 AA..AA is the start address, LLLL is the number of bytes, and
1128 XX..XX is the binary data.
1129 Success: OK
1130 Failure: void. */
1131 case 'M':
1132 /* Write to memory. MAA..AA,LLLL:XX..XX
1133 AA..AA is the start address, LLLL is the number of bytes, and
1134 XX..XX is the hexadecimal data.
1135 Success: OK
1136 Failure: void. */
1138 char *lenptr;
1139 char *dataptr;
1140 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
1141 &lenptr, 16);
1142 int length = gdb_cris_strtol(lenptr+1, &dataptr, 16);
1143 if (*lenptr == ',' && *dataptr == ':') {
1144 if (remcomInBuffer[0] == 'M') {
1145 hex2mem(addr, dataptr + 1, length);
1147 else /* X */ {
1148 bin2mem(addr, dataptr + 1, length);
1150 gdb_cris_strcpy (remcomOutBuffer, "OK");
1152 else {
1153 gdb_cris_strcpy (remcomOutBuffer, error_message[E06]);
1156 break;
1158 case 'c':
1159 /* Continue execution. cAA..AA
1160 AA..AA is the address where execution is resumed. If AA..AA is
1161 omitted, resume at the present address.
1162 Success: return to the executing thread.
1163 Failure: will never know. */
1164 if (remcomInBuffer[1] != '\0') {
1165 reg.pc = gdb_cris_strtol (&remcomInBuffer[1], 0, 16);
1167 enableDebugIRQ();
1168 return;
1170 case 's':
1171 /* Step. sAA..AA
1172 AA..AA is the address where execution is resumed. If AA..AA is
1173 omitted, resume at the present address. Success: return to the
1174 executing thread. Failure: will never know.
1176 Should never be invoked. The single-step is implemented on
1177 the host side. If ever invoked, it is an internal error E04. */
1178 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
1179 putpacket (remcomOutBuffer);
1180 return;
1182 case '?':
1183 /* The last signal which caused a stop. ?
1184 Success: SAA, where AA is the signal number.
1185 Failure: void. */
1186 remcomOutBuffer[0] = 'S';
1187 remcomOutBuffer[1] = highhex (sigval);
1188 remcomOutBuffer[2] = lowhex (sigval);
1189 remcomOutBuffer[3] = 0;
1190 break;
1192 case 'D':
1193 /* Detach from host. D
1194 Success: OK, and return to the executing thread.
1195 Failure: will never know */
1196 putpacket ("OK");
1197 return;
1199 case 'k':
1200 case 'r':
1201 /* kill request or reset request.
1202 Success: restart of target.
1203 Failure: will never know. */
1204 kill_restart ();
1205 break;
1207 case 'C':
1208 case 'S':
1209 case '!':
1210 case 'R':
1211 case 'd':
1212 /* Continue with signal sig. Csig;AA..AA
1213 Step with signal sig. Ssig;AA..AA
1214 Use the extended remote protocol. !
1215 Restart the target system. R0
1216 Toggle debug flag. d
1217 Search backwards. tAA:PP,MM
1218 Not supported: E04 */
1219 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
1220 break;
1221 #ifdef PROCESS_SUPPORT
1223 case 'T':
1224 /* Thread alive. TXX
1225 Is thread XX alive?
1226 Success: OK, thread XX is alive.
1227 Failure: E03, thread XX is dead. */
1229 int thread_id = (int)gdb_cris_strtol (&remcomInBuffer[1], 0, 16);
1230 /* Cannot tell whether it is alive or not. */
1231 if (thread_id >= 0 && thread_id < number_of_tasks)
1232 gdb_cris_strcpy (remcomOutBuffer, "OK");
1234 break;
1236 case 'H':
1237 /* Set thread for subsequent operations: Hct
1238 c = 'c' for thread used in step and continue;
1239 t can be -1 for all threads.
1240 c = 'g' for thread used in other operations.
1241 t = 0 means pick any thread.
1242 Success: OK
1243 Failure: E01 */
1245 int thread_id = gdb_cris_strtol (&remcomInBuffer[2], 0, 16);
1246 if (remcomInBuffer[1] == 'c') {
1247 /* c = 'c' for thread used in step and continue */
1248 /* Do not change current_thread_c here. It would create a mess in
1249 the scheduler. */
1250 gdb_cris_strcpy (remcomOutBuffer, "OK");
1252 else if (remcomInBuffer[1] == 'g') {
1253 /* c = 'g' for thread used in other operations.
1254 t = 0 means pick any thread. Impossible since the scheduler does
1255 not allow that. */
1256 if (thread_id >= 0 && thread_id < number_of_tasks) {
1257 current_thread_g = thread_id;
1258 gdb_cris_strcpy (remcomOutBuffer, "OK");
1260 else {
1261 /* Not expected - send an error message. */
1262 gdb_cris_strcpy (remcomOutBuffer, error_message[E01]);
1265 else {
1266 /* Not expected - send an error message. */
1267 gdb_cris_strcpy (remcomOutBuffer, error_message[E01]);
1270 break;
1272 case 'q':
1273 case 'Q':
1274 /* Query of general interest. qXXXX
1275 Set general value XXXX. QXXXX=yyyy */
1277 int pos;
1278 int nextpos;
1279 int thread_id;
1281 switch (remcomInBuffer[1]) {
1282 case 'C':
1283 /* Identify the remote current thread. */
1284 gdb_cris_strcpy (&remcomOutBuffer[0], "QC");
1285 remcomOutBuffer[2] = highhex (current_thread_c);
1286 remcomOutBuffer[3] = lowhex (current_thread_c);
1287 remcomOutBuffer[4] = '\0';
1288 break;
1289 case 'L':
1290 gdb_cris_strcpy (&remcomOutBuffer[0], "QM");
1291 /* Reply with number of threads. */
1292 if (os_is_started()) {
1293 remcomOutBuffer[2] = highhex (number_of_tasks);
1294 remcomOutBuffer[3] = lowhex (number_of_tasks);
1296 else {
1297 remcomOutBuffer[2] = highhex (0);
1298 remcomOutBuffer[3] = lowhex (1);
1300 /* Done with the reply. */
1301 remcomOutBuffer[4] = lowhex (1);
1302 pos = 5;
1303 /* Expects the argument thread id. */
1304 for (; pos < (5 + HEXCHARS_IN_THREAD_ID); pos++)
1305 remcomOutBuffer[pos] = remcomInBuffer[pos];
1306 /* Reply with the thread identifiers. */
1307 if (os_is_started()) {
1308 /* Store the thread identifiers of all tasks. */
1309 for (thread_id = 0; thread_id < number_of_tasks; thread_id++) {
1310 nextpos = pos + HEXCHARS_IN_THREAD_ID - 1;
1311 for (; pos < nextpos; pos ++)
1312 remcomOutBuffer[pos] = lowhex (0);
1313 remcomOutBuffer[pos++] = lowhex (thread_id);
1316 else {
1317 /* Store the thread identifier of the boot task. */
1318 nextpos = pos + HEXCHARS_IN_THREAD_ID - 1;
1319 for (; pos < nextpos; pos ++)
1320 remcomOutBuffer[pos] = lowhex (0);
1321 remcomOutBuffer[pos++] = lowhex (current_thread_c);
1323 remcomOutBuffer[pos] = '\0';
1324 break;
1325 default:
1326 /* Not supported: "" */
1327 /* Request information about section offsets: qOffsets. */
1328 remcomOutBuffer[0] = 0;
1329 break;
1332 break;
1333 #endif /* PROCESS_SUPPORT */
1335 default:
1336 /* The stub should ignore other request and send an empty
1337 response ($#<checksum>). This way we can extend the protocol and GDB
1338 can tell whether the stub it is talking to uses the old or the new. */
1339 remcomOutBuffer[0] = 0;
1340 break;
1342 putpacket(remcomOutBuffer);
1346 /* Performs a complete re-start from scratch. */
1347 static void
1348 kill_restart ()
1350 machine_restart("");
1353 /********************************** Breakpoint *******************************/
1354 /* The hook for both a static (compiled) and a dynamic breakpoint set by GDB.
1355 An internal stack is used by the stub. The register image of the caller is
1356 stored in the structure register_image.
1357 Interactive communication with the host is handled by handle_exception and
1358 finally the register image is restored. */
1360 void kgdb_handle_breakpoint(void);
1362 asm ("
1363 .global kgdb_handle_breakpoint
1364 kgdb_handle_breakpoint:
1365 ;;
1366 ;; Response to the break-instruction
1367 ;;
1368 ;; Create a register image of the caller
1369 ;;
1370 move $dccr,[reg+0x5E] ; Save the flags in DCCR before disable interrupts
1371 di ; Disable interrupts
1372 move.d $r0,[reg] ; Save R0
1373 move.d $r1,[reg+0x04] ; Save R1
1374 move.d $r2,[reg+0x08] ; Save R2
1375 move.d $r3,[reg+0x0C] ; Save R3
1376 move.d $r4,[reg+0x10] ; Save R4
1377 move.d $r5,[reg+0x14] ; Save R5
1378 move.d $r6,[reg+0x18] ; Save R6
1379 move.d $r7,[reg+0x1C] ; Save R7
1380 move.d $r8,[reg+0x20] ; Save R8
1381 move.d $r9,[reg+0x24] ; Save R9
1382 move.d $r10,[reg+0x28] ; Save R10
1383 move.d $r11,[reg+0x2C] ; Save R11
1384 move.d $r12,[reg+0x30] ; Save R12
1385 move.d $r13,[reg+0x34] ; Save R13
1386 move.d $sp,[reg+0x38] ; Save SP (R14)
1387 ;; Due to the old assembler-versions BRP might not be recognized
1388 .word 0xE670 ; move brp,$r0
1389 subq 2,$r0 ; Set to address of previous instruction.
1390 move.d $r0,[reg+0x3c] ; Save the address in PC (R15)
1391 clear.b [reg+0x40] ; Clear P0
1392 move $vr,[reg+0x41] ; Save special register P1
1393 clear.w [reg+0x42] ; Clear P4
1394 move $ccr,[reg+0x44] ; Save special register CCR
1395 move $mof,[reg+0x46] ; P7
1396 clear.d [reg+0x4A] ; Clear P8
1397 move $ibr,[reg+0x4E] ; P9,
1398 move $irp,[reg+0x52] ; P10,
1399 move $srp,[reg+0x56] ; P11,
1400 move $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR
1401 ; P13, register DCCR already saved
1402 ;; Due to the old assembler-versions BRP might not be recognized
1403 .word 0xE670 ; move brp,r0
1404 ;; Static (compiled) breakpoints must return to the next instruction in order
1405 ;; to avoid infinite loops. Dynamic (gdb-invoked) must restore the instruction
1406 ;; in order to execute it when execution is continued.
1407 test.b [is_dyn_brkp] ; Is this a dynamic breakpoint?
1408 beq is_static ; No, a static breakpoint
1409 nop
1410 subq 2,$r0 ; rerun the instruction the break replaced
1411 is_static:
1412 moveq 1,$r1
1413 move.b $r1,[is_dyn_brkp] ; Set the state variable to dynamic breakpoint
1414 move.d $r0,[reg+0x62] ; Save the return address in BRP
1415 move $usp,[reg+0x66] ; USP
1416 ;;
1417 ;; Handle the communication
1418 ;;
1419 move.d internal_stack+1020,$sp ; Use the internal stack which grows upward
1420 moveq 5,$r10 ; SIGTRAP
1421 jsr handle_exception ; Interactive routine
1422 ;;
1423 ;; Return to the caller
1424 ;;
1425 move.d [reg],$r0 ; Restore R0
1426 move.d [reg+0x04],$r1 ; Restore R1
1427 move.d [reg+0x08],$r2 ; Restore R2
1428 move.d [reg+0x0C],$r3 ; Restore R3
1429 move.d [reg+0x10],$r4 ; Restore R4
1430 move.d [reg+0x14],$r5 ; Restore R5
1431 move.d [reg+0x18],$r6 ; Restore R6
1432 move.d [reg+0x1C],$r7 ; Restore R7
1433 move.d [reg+0x20],$r8 ; Restore R8
1434 move.d [reg+0x24],$r9 ; Restore R9
1435 move.d [reg+0x28],$r10 ; Restore R10
1436 move.d [reg+0x2C],$r11 ; Restore R11
1437 move.d [reg+0x30],$r12 ; Restore R12
1438 move.d [reg+0x34],$r13 ; Restore R13
1439 ;;
1440 ;; FIXME: Which registers should be restored?
1441 ;;
1442 move.d [reg+0x38],$sp ; Restore SP (R14)
1443 move [reg+0x56],$srp ; Restore the subroutine return pointer.
1444 move [reg+0x5E],$dccr ; Restore DCCR
1445 move [reg+0x66],$usp ; Restore USP
1446 jump [reg+0x62] ; A jump to the content in register BRP works.
1447 nop ;
1448 ");
1450 /* The hook for an interrupt generated by GDB. An internal stack is used
1451 by the stub. The register image of the caller is stored in the structure
1452 register_image. Interactive communication with the host is handled by
1453 handle_exception and finally the register image is restored. Due to the
1454 old assembler which does not recognise the break instruction and the
1455 breakpoint return pointer hex-code is used. */
1457 void kgdb_handle_serial(void);
1459 asm ("
1460 .global kgdb_handle_serial
1461 kgdb_handle_serial:
1462 ;;
1463 ;; Response to a serial interrupt
1464 ;;
1466 move $dccr,[reg+0x5E] ; Save the flags in DCCR
1467 di ; Disable interrupts
1468 move.d $r0,[reg] ; Save R0
1469 move.d $r1,[reg+0x04] ; Save R1
1470 move.d $r2,[reg+0x08] ; Save R2
1471 move.d $r3,[reg+0x0C] ; Save R3
1472 move.d $r4,[reg+0x10] ; Save R4
1473 move.d $r5,[reg+0x14] ; Save R5
1474 move.d $r6,[reg+0x18] ; Save R6
1475 move.d $r7,[reg+0x1C] ; Save R7
1476 move.d $r8,[reg+0x20] ; Save R8
1477 move.d $r9,[reg+0x24] ; Save R9
1478 move.d $r10,[reg+0x28] ; Save R10
1479 move.d $r11,[reg+0x2C] ; Save R11
1480 move.d $r12,[reg+0x30] ; Save R12
1481 move.d $r13,[reg+0x34] ; Save R13
1482 move.d $sp,[reg+0x38] ; Save SP (R14)
1483 move $irp,[reg+0x3c] ; Save the address in PC (R15)
1484 clear.b [reg+0x40] ; Clear P0
1485 move $vr,[reg+0x41] ; Save special register P1,
1486 clear.w [reg+0x42] ; Clear P4
1487 move $ccr,[reg+0x44] ; Save special register CCR
1488 move $mof,[reg+0x46] ; P7
1489 clear.d [reg+0x4A] ; Clear P8
1490 move $ibr,[reg+0x4E] ; P9,
1491 move $irp,[reg+0x52] ; P10,
1492 move $srp,[reg+0x56] ; P11,
1493 move $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR
1494 ; P13, register DCCR already saved
1495 ;; Due to the old assembler-versions BRP might not be recognized
1496 .word 0xE670 ; move brp,r0
1497 move.d $r0,[reg+0x62] ; Save the return address in BRP
1498 move $usp,[reg+0x66] ; USP
1500 ;; get the serial character (from debugport.c) and check if it is a ctrl-c
1502 jsr getDebugChar
1503 cmp.b 3, $r10
1504 bne goback
1505 nop
1507 move.d [reg+0x5E], $r10 ; Get DCCR
1508 btstq 8, $r10 ; Test the U-flag.
1509 bmi goback
1510 nop
1512 ;;
1513 ;; Handle the communication
1514 ;;
1515 move.d internal_stack+1020,$sp ; Use the internal stack
1516 moveq 2,$r10 ; SIGINT
1517 jsr handle_exception ; Interactive routine
1519 goback:
1520 ;;
1521 ;; Return to the caller
1522 ;;
1523 move.d [reg],$r0 ; Restore R0
1524 move.d [reg+0x04],$r1 ; Restore R1
1525 move.d [reg+0x08],$r2 ; Restore R2
1526 move.d [reg+0x0C],$r3 ; Restore R3
1527 move.d [reg+0x10],$r4 ; Restore R4
1528 move.d [reg+0x14],$r5 ; Restore R5
1529 move.d [reg+0x18],$r6 ; Restore R6
1530 move.d [reg+0x1C],$r7 ; Restore R7
1531 move.d [reg+0x20],$r8 ; Restore R8
1532 move.d [reg+0x24],$r9 ; Restore R9
1533 move.d [reg+0x28],$r10 ; Restore R10
1534 move.d [reg+0x2C],$r11 ; Restore R11
1535 move.d [reg+0x30],$r12 ; Restore R12
1536 move.d [reg+0x34],$r13 ; Restore R13
1537 ;;
1538 ;; FIXME: Which registers should be restored?
1539 ;;
1540 move.d [reg+0x38],$sp ; Restore SP (R14)
1541 move [reg+0x56],$srp ; Restore the subroutine return pointer.
1542 move [reg+0x5E],$dccr ; Restore DCCR
1543 move [reg+0x66],$usp ; Restore USP
1544 reti ; Return from the interrupt routine
1545 nop
1546 ");
1548 /* Use this static breakpoint in the start-up only. */
1550 void
1551 breakpoint(void)
1553 kgdb_started = 1;
1554 is_dyn_brkp = 0; /* This is a static, not a dynamic breakpoint. */
1555 __asm__ volatile ("break 8"); /* Jump to handle_breakpoint. */
1558 /* initialize kgdb. doesn't break into the debugger, but sets up irq and ports */
1560 void
1561 kgdb_init(void)
1563 /* could initialize debug port as well but it's done in head.S already... */
1565 /* breakpoint handler is now set in irq.c */
1566 set_int_vector(8, kgdb_handle_serial);
1568 enableDebugIRQ();
1571 /****************************** End of file **********************************/