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