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 182static 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 194typedef 195struct 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 */ 234int getDebugChar (void); 235 236/* Serial port, writes one character. ETRAX 100 specific. from debugport.c */ 237void putDebugChar (int val); 238 239void enableDebugIRQ (void); 240 241/******************** Prototypes for global functions. ***********************/ 242 243/* The string str is prepended with the GDB printout token and sent. */ 244void 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. */ 248void handle_breakpoint (void); /* used by irq.c */ 249 250/* The hook for an interrupt generated by GDB. ETRAX 100 specific. */ 251void handle_interrupt (void); /* used by irq.c */ 252 253/* A static breakpoint to be used at startup. */ 254void 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. */ 258extern 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/********************************** Packet I/O ******************************/ 264/* BUFMAX defines the maximum number of characters in 265 inbound/outbound buffers */ 266#define BUFMAX 512 267 268/* Run-length encoding maximum length. Send 64 at most. */ 269#define RUNLENMAX 64 270 271/* The inbound/outbound buffers used in packet I/O */ 272static char remcomInBuffer[BUFMAX]; 273static char remcomOutBuffer[BUFMAX]; 274 275/* Error and warning messages. */ 276enum error_type 277{ 278 SUCCESS, E01, E02, E03, E04, E05, E06, E07 279}; 280static char *error_message[] = 281{ 282 "", 283 "E01 Set current or general thread - H[c,g] - internal error.", 284 "E02 Change register content - P - cannot change read-only register.", 285 "E03 Thread is not alive.", /* T, not used. */ 286 "E04 The command is not supported - [s,C,S,!,R,d,r] - internal error.", 287 "E05 Change register content - P - the register is not implemented..", 288 "E06 Change memory content - M - internal error.", 289 "E07 Change register content - P - the register is not stored on the stack" 290}; 291/********************************* Register image ****************************/ 292/* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's 293 Reference", p. 1-1, with the additional register definitions of the 294 ETRAX 100LX in cris-opc.h. 295 There are 16 general 32-bit registers, R0-R15, where R14 is the stack 296 pointer, SP, and R15 is the program counter, PC. 297 There are 16 special registers, P0-P15, where three of the unimplemented 298 registers, P0, P4 and P8, are reserved as zero-registers. A read from 299 any of these registers returns zero and a write has no effect. */ 300enum register_name 301{ 302 R0, R1, R2, R3, 303 R4, R5, R6, R7, 304 R8, R9, R10, R11, 305 R12, R13, SP, PC, 306 P0, VR, P2, P3, 307 P4, CCR, P6, MOF, 308 P8, IBR, IRP, SRP, 309 BAR, DCCR, BRP, USP 310}; 311 312/* The register sizes of the registers in register_name. An unimplemented register 313 is designated by size 0 in this array. */ 314static int register_size[] = 315{ 316 4, 4, 4, 4, 317 4, 4, 4, 4, 318 4, 4, 4, 4, 319 4, 4, 4, 4, 320 1, 1, 0, 0, 321 2, 2, 0, 4, 322 4, 4, 4, 4, 323 4, 4, 4, 4 324}; 325 326/* Contains the register image of the executing thread in the assembler 327 part of the code in order to avoid horrible addressing modes. */ 328registers cris_reg; 329 330/* FIXME: Should this be used? Delete otherwise. */ 331/* Contains the assumed consistency state of the register image. Uses the 332 enum error_type for state information. */ 333static int consistency_status = SUCCESS; 334 335/********************************** Handle exceptions ************************/ 336/* The variable cris_reg contains the register image associated with the 337 current_thread_c variable. It is a complete register image created at 338 entry. The reg_g contains a register image of a task where the general 339 registers are taken from the stack and all special registers are taken 340 from the executing task. It is associated with current_thread_g and used 341 in order to provide access mainly for 'g', 'G' and 'P'. 342*/ 343 344/********************************** Breakpoint *******************************/ 345/* Use an internal stack in the breakpoint and interrupt response routines */ 346#define INTERNAL_STACK_SIZE 1024 347char internal_stack[INTERNAL_STACK_SIZE]; 348 349/* Due to the breakpoint return pointer, a state variable is needed to keep 350 track of whether it is a static (compiled) or dynamic (gdb-invoked) 351 breakpoint to be handled. A static breakpoint uses the content of register 352 BRP as it is whereas a dynamic breakpoint requires subtraction with 2 353 in order to execute the instruction. The first breakpoint is static. */ 354static unsigned char is_dyn_brkp = 0; 355 356/********************************* String library ****************************/ 357/* Single-step over library functions creates trap loops. */ 358 359/* Copy char s2[] to s1[]. */ 360static char* 361gdb_cris_strcpy (char *s1, const char *s2) 362{ 363 char *s = s1; 364 365 for (s = s1; (*s++ = *s2++) != '\0'; ) 366 ; 367 return (s1); 368} 369 370/* Find length of s[]. */ 371static int 372gdb_cris_strlen (const char *s) 373{ 374 const char *sc; 375 376 for (sc = s; *sc != '\0'; sc++) 377 ; 378 return (sc - s); 379} 380 381/* Find first occurrence of c in s[n]. */ 382static void* 383gdb_cris_memchr (const void *s, int c, int n) 384{ 385 const unsigned char uc = c; 386 const unsigned char *su; 387 388 for (su = s; 0 < n; ++su, --n) 389 if (*su == uc) 390 return ((void *)su); 391 return (NULL); 392} 393/******************************* Standard library ****************************/ 394/* Single-step over library functions creates trap loops. */ 395/* Convert string to long. */ 396static int 397gdb_cris_strtol (const char *s, char **endptr, int base) 398{ 399 char *s1; 400 char *sd; 401 int x = 0; 402 403 for (s1 = (char*)s; (sd = gdb_cris_memchr(hex_asc, *s1, base)) != NULL; ++s1) 404 x = x * base + (sd - hex_asc); 405 406 if (endptr) 407 { 408 /* Unconverted suffix is stored in endptr unless endptr is NULL. */ 409 *endptr = s1; 410 } 411 412 return x; 413} 414 415/********************************** Packet I/O ******************************/ 416/* Returns the integer equivalent of a hexadecimal character. */ 417static int 418hex (char ch) 419{ 420 if ((ch >= 'a') && (ch <= 'f')) 421 return (ch - 'a' + 10); 422 if ((ch >= '0') && (ch <= '9')) 423 return (ch - '0'); 424 if ((ch >= 'A') && (ch <= 'F')) 425 return (ch - 'A' + 10); 426 return (-1); 427} 428 429/* Convert the memory, pointed to by mem into hexadecimal representation. 430 Put the result in buf, and return a pointer to the last character 431 in buf (null). */ 432 433static char * 434mem2hex(char *buf, unsigned char *mem, int count) 435{ 436 int i; 437 int ch; 438 439 if (mem == NULL) { 440 /* Bogus read from m0. FIXME: What constitutes a valid address? */ 441 for (i = 0; i < count; i++) { 442 *buf++ = '0'; 443 *buf++ = '0'; 444 } 445 } else { 446 /* Valid mem address. */ 447 for (i = 0; i < count; i++) { 448 ch = *mem++; 449 buf = hex_byte_pack(buf, ch); 450 } 451 } 452 453 /* Terminate properly. */ 454 *buf = '\0'; 455 return (buf); 456} 457 458/* Convert the array, in hexadecimal representation, pointed to by buf into 459 binary representation. Put the result in mem, and return a pointer to 460 the character after the last byte written. */ 461static unsigned char* 462hex2mem (unsigned char *mem, char *buf, int count) 463{ 464 int i; 465 unsigned char ch; 466 for (i = 0; i < count; i++) { 467 ch = hex (*buf++) << 4; 468 ch = ch + hex (*buf++); 469 *mem++ = ch; 470 } 471 return (mem); 472} 473 474/* Put the content of the array, in binary representation, pointed to by buf 475 into memory pointed to by mem, and return a pointer to the character after 476 the last byte written. 477 Gdb will escape $, #, and the escape char (0x7d). */ 478static unsigned char* 479bin2mem (unsigned char *mem, unsigned char *buf, int count) 480{ 481 int i; 482 unsigned char *next; 483 for (i = 0; i < count; i++) { 484 /* Check for any escaped characters. Be paranoid and 485 only unescape chars that should be escaped. */ 486 if (*buf == 0x7d) { 487 next = buf + 1; 488 if (*next == 0x3 || *next == 0x4 || *next == 0x5D) /* #, $, ESC */ 489 { 490 buf++; 491 *buf += 0x20; 492 } 493 } 494 *mem++ = *buf++; 495 } 496 return (mem); 497} 498 499/* Await the sequence $<data>#<checksum> and store <data> in the array buffer 500 returned. */ 501static void 502getpacket (char *buffer) 503{ 504 unsigned char checksum; 505 unsigned char xmitcsum; 506 int i; 507 int count; 508 char ch; 509 do { 510 while ((ch = getDebugChar ()) != '$') 511 /* Wait for the start character $ and ignore all other characters */; 512 checksum = 0; 513 xmitcsum = -1; 514 count = 0; 515 /* Read until a # or the end of the buffer is reached */ 516 while (count < BUFMAX - 1) { 517 ch = getDebugChar (); 518 if (ch == '#') 519 break; 520 checksum = checksum + ch; 521 buffer[count] = ch; 522 count = count + 1; 523 } 524 buffer[count] = '\0'; 525 526 if (ch == '#') { 527 xmitcsum = hex (getDebugChar ()) << 4; 528 xmitcsum += hex (getDebugChar ()); 529 if (checksum != xmitcsum) { 530 /* Wrong checksum */ 531 putDebugChar ('-'); 532 } 533 else { 534 /* Correct checksum */ 535 putDebugChar ('+'); 536 /* If sequence characters are received, reply with them */ 537 if (buffer[2] == ':') { 538 putDebugChar (buffer[0]); 539 putDebugChar (buffer[1]); 540 /* Remove the sequence characters from the buffer */ 541 count = gdb_cris_strlen (buffer); 542 for (i = 3; i <= count; i++) 543 buffer[i - 3] = buffer[i]; 544 } 545 } 546 } 547 } while (checksum != xmitcsum); 548} 549 550/* Send $<data>#<checksum> from the <data> in the array buffer. */ 551 552static void 553putpacket(char *buffer) 554{ 555 int checksum; 556 int runlen; 557 int encode; 558 559 do { 560 char *src = buffer; 561 putDebugChar ('$'); 562 checksum = 0; 563 while (*src) { 564 /* Do run length encoding */ 565 putDebugChar (*src); 566 checksum += *src; 567 runlen = 0; 568 while (runlen < RUNLENMAX && *src == src[runlen]) { 569 runlen++; 570 } 571 if (runlen > 3) { 572 /* Got a useful amount */ 573 putDebugChar ('*'); 574 checksum += '*'; 575 encode = runlen + ' ' - 4; 576 putDebugChar (encode); 577 checksum += encode; 578 src += runlen; 579 } 580 else { 581 src++; 582 } 583 } 584 putDebugChar('#'); 585 putDebugChar(hex_asc_hi(checksum)); 586 putDebugChar(hex_asc_lo(checksum)); 587 } while(kgdb_started && (getDebugChar() != '+')); 588} 589 590/* The string str is prepended with the GDB printout token and sent. Required 591 in traditional implementations. */ 592void 593putDebugString (const unsigned char *str, int length) 594{ 595 remcomOutBuffer[0] = 'O'; 596 mem2hex(&remcomOutBuffer[1], (unsigned char *)str, length); 597 putpacket(remcomOutBuffer); 598} 599 600/********************************* Register image ****************************/ 601/* Write a value to a specified register in the register image of the current 602 thread. Returns status code SUCCESS, E02 or E05. */ 603static int 604write_register (int regno, char *val) 605{ 606 int status = SUCCESS; 607 registers *current_reg = &cris_reg; 608 609 if (regno >= R0 && regno <= PC) { 610 /* 32-bit register with simple offset. */ 611 hex2mem ((unsigned char *)current_reg + regno * sizeof(unsigned int), 612 val, sizeof(unsigned int)); 613 } 614 else if (regno == P0 || regno == VR || regno == P4 || regno == P8) { 615 /* Do not support read-only registers. */ 616 status = E02; 617 } 618 else if (regno == CCR) { 619 /* 16 bit register with complex offset. (P4 is read-only, P6 is not implemented, 620 and P7 (MOF) is 32 bits in ETRAX 100LX. */ 621 hex2mem ((unsigned char *)&(current_reg->ccr) + (regno-CCR) * sizeof(unsigned short), 622 val, sizeof(unsigned short)); 623 } 624 else if (regno >= MOF && regno <= USP) { 625 /* 32 bit register with complex offset. (P8 has been taken care of.) */ 626 hex2mem ((unsigned char *)&(current_reg->ibr) + (regno-IBR) * sizeof(unsigned int), 627 val, sizeof(unsigned int)); 628 } 629 else { 630 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */ 631 status = E05; 632 } 633 return status; 634} 635 636/* Read a value from a specified register in the register image. Returns the 637 value in the register or -1 for non-implemented registers. 638 Should check consistency_status after a call which may be E05 after changes 639 in the implementation. */ 640static int 641read_register (char regno, unsigned int *valptr) 642{ 643 registers *current_reg = &cris_reg; 644 645 if (regno >= R0 && regno <= PC) { 646 /* 32-bit register with simple offset. */ 647 *valptr = *(unsigned int *)((char *)current_reg + regno * sizeof(unsigned int)); 648 return SUCCESS; 649 } 650 else if (regno == P0 || regno == VR) { 651 /* 8 bit register with complex offset. */ 652 *valptr = (unsigned int)(*(unsigned char *) 653 ((char *)&(current_reg->p0) + (regno-P0) * sizeof(char))); 654 return SUCCESS; 655 } 656 else if (regno == P4 || regno == CCR) { 657 /* 16 bit register with complex offset. */ 658 *valptr = (unsigned int)(*(unsigned short *) 659 ((char *)&(current_reg->p4) + (regno-P4) * sizeof(unsigned short))); 660 return SUCCESS; 661 } 662 else if (regno >= MOF && regno <= USP) { 663 /* 32 bit register with complex offset. */ 664 *valptr = *(unsigned int *)((char *)&(current_reg->p8) 665 + (regno-P8) * sizeof(unsigned int)); 666 return SUCCESS; 667 } 668 else { 669 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */ 670 consistency_status = E05; 671 return E05; 672 } 673} 674 675/********************************** Handle exceptions ************************/ 676/* Build and send a response packet in order to inform the host the 677 stub is stopped. TAAn...:r...;n...:r...;n...:r...; 678 AA = signal number 679 n... = register number (hex) 680 r... = register contents 681 n... = `thread' 682 r... = thread process ID. This is a hex integer. 683 n... = other string not starting with valid hex digit. 684 gdb should ignore this n,r pair and go on to the next. 685 This way we can extend the protocol. */ 686static void 687stub_is_stopped(int sigval) 688{ 689 char *ptr = remcomOutBuffer; 690 int regno; 691 692 unsigned int reg_cont; 693 int status; 694 695 /* Send trap type (converted to signal) */ 696 697 *ptr++ = 'T'; 698 ptr = hex_byte_pack(ptr, sigval); 699 700 /* Send register contents. We probably only need to send the 701 * PC, frame pointer and stack pointer here. Other registers will be 702 * explicitly asked for. But for now, send all. 703 */ 704 705 for (regno = R0; regno <= USP; regno++) { 706 /* Store n...:r...; for the registers in the buffer. */ 707 708 status = read_register (regno, ®_cont); 709 710 if (status == SUCCESS) { 711 ptr = hex_byte_pack(ptr, regno); 712 *ptr++ = ':'; 713 714 ptr = mem2hex(ptr, (unsigned char *)®_cont, 715 register_size[regno]); 716 *ptr++ = ';'; 717 } 718 719 } 720 721 /* null-terminate and send it off */ 722 723 *ptr = 0; 724 725 putpacket (remcomOutBuffer); 726} 727 728/* Performs a complete re-start from scratch. */ 729static void 730kill_restart (void) 731{ 732 machine_restart(""); 733} 734 735/* All expected commands are sent from remote.c. Send a response according 736 to the description in remote.c. */ 737void 738handle_exception (int sigval) 739{ 740 /* Send response. */ 741 742 stub_is_stopped (sigval); 743 744 for (;;) { 745 remcomOutBuffer[0] = '\0'; 746 getpacket (remcomInBuffer); 747 switch (remcomInBuffer[0]) { 748 case 'g': 749 /* Read registers: g 750 Success: Each byte of register data is described by two hex digits. 751 Registers are in the internal order for GDB, and the bytes 752 in a register are in the same order the machine uses. 753 Failure: void. */ 754 755 mem2hex(remcomOutBuffer, (char *)&cris_reg, sizeof(registers)); 756 break; 757 758 case 'G': 759 /* Write registers. GXX..XX 760 Each byte of register data is described by two hex digits. 761 Success: OK 762 Failure: void. */ 763 hex2mem((char *)&cris_reg, &remcomInBuffer[1], sizeof(registers)); 764 gdb_cris_strcpy (remcomOutBuffer, "OK"); 765 break; 766 767 case 'P': 768 /* Write register. Pn...=r... 769 Write register n..., hex value without 0x, with value r..., 770 which contains a hex value without 0x and two hex digits 771 for each byte in the register (target byte order). P1f=11223344 means 772 set register 31 to 44332211. 773 Success: OK 774 Failure: E02, E05 */ 775 { 776 char *suffix; 777 int regno = gdb_cris_strtol (&remcomInBuffer[1], &suffix, 16); 778 int status; 779 status = write_register (regno, suffix+1); 780 781 switch (status) { 782 case E02: 783 /* Do not support read-only registers. */ 784 gdb_cris_strcpy (remcomOutBuffer, error_message[E02]); 785 break; 786 case E05: 787 /* Do not support non-existing registers. */ 788 gdb_cris_strcpy (remcomOutBuffer, error_message[E05]); 789 break; 790 case E07: 791 /* Do not support non-existing registers on the stack. */ 792 gdb_cris_strcpy (remcomOutBuffer, error_message[E07]); 793 break; 794 default: 795 /* Valid register number. */ 796 gdb_cris_strcpy (remcomOutBuffer, "OK"); 797 break; 798 } 799 } 800 break; 801 802 case 'm': 803 /* Read from memory. mAA..AA,LLLL 804 AA..AA is the address and LLLL is the length. 805 Success: XX..XX is the memory content. Can be fewer bytes than 806 requested if only part of the data may be read. m6000120a,6c means 807 retrieve 108 byte from base address 6000120a. 808 Failure: void. */ 809 { 810 char *suffix; 811 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1], 812 &suffix, 16); int length = gdb_cris_strtol(suffix+1, 0, 16); 813 814 mem2hex(remcomOutBuffer, addr, length); 815 } 816 break; 817 818 case 'X': 819 /* Write to memory. XAA..AA,LLLL:XX..XX 820 AA..AA is the start address, LLLL is the number of bytes, and 821 XX..XX is the binary data. 822 Success: OK 823 Failure: void. */ 824 case 'M': 825 /* Write to memory. MAA..AA,LLLL:XX..XX 826 AA..AA is the start address, LLLL is the number of bytes, and 827 XX..XX is the hexadecimal data. 828 Success: OK 829 Failure: void. */ 830 { 831 char *lenptr; 832 char *dataptr; 833 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1], 834 &lenptr, 16); 835 int length = gdb_cris_strtol(lenptr+1, &dataptr, 16); 836 if (*lenptr == ',' && *dataptr == ':') { 837 if (remcomInBuffer[0] == 'M') { 838 hex2mem(addr, dataptr + 1, length); 839 } 840 else /* X */ { 841 bin2mem(addr, dataptr + 1, length); 842 } 843 gdb_cris_strcpy (remcomOutBuffer, "OK"); 844 } 845 else { 846 gdb_cris_strcpy (remcomOutBuffer, error_message[E06]); 847 } 848 } 849 break; 850 851 case 'c': 852 /* Continue execution. cAA..AA 853 AA..AA is the address where execution is resumed. If AA..AA is 854 omitted, resume at the present address. 855 Success: return to the executing thread. 856 Failure: will never know. */ 857 if (remcomInBuffer[1] != '\0') { 858 cris_reg.pc = gdb_cris_strtol (&remcomInBuffer[1], 0, 16); 859 } 860 enableDebugIRQ(); 861 return; 862 863 case 's': 864 /* Step. sAA..AA 865 AA..AA is the address where execution is resumed. If AA..AA is 866 omitted, resume at the present address. Success: return to the 867 executing thread. Failure: will never know. 868 869 Should never be invoked. The single-step is implemented on 870 the host side. If ever invoked, it is an internal error E04. */ 871 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]); 872 putpacket (remcomOutBuffer); 873 return; 874 875 case '?': 876 /* The last signal which caused a stop. ? 877 Success: SAA, where AA is the signal number. 878 Failure: void. */ 879 remcomOutBuffer[0] = 'S'; 880 remcomOutBuffer[1] = hex_asc_hi(sigval); 881 remcomOutBuffer[2] = hex_asc_lo(sigval); 882 remcomOutBuffer[3] = 0; 883 break; 884 885 case 'D': 886 /* Detach from host. D 887 Success: OK, and return to the executing thread. 888 Failure: will never know */ 889 putpacket ("OK"); 890 return; 891 892 case 'k': 893 case 'r': 894 /* kill request or reset request. 895 Success: restart of target. 896 Failure: will never know. */ 897 kill_restart (); 898 break; 899 900 case 'C': 901 case 'S': 902 case '!': 903 case 'R': 904 case 'd': 905 /* Continue with signal sig. Csig;AA..AA 906 Step with signal sig. Ssig;AA..AA 907 Use the extended remote protocol. ! 908 Restart the target system. R0 909 Toggle debug flag. d 910 Search backwards. tAA:PP,MM 911 Not supported: E04 */ 912 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]); 913 break; 914 915 default: 916 /* The stub should ignore other request and send an empty 917 response ($#<checksum>). This way we can extend the protocol and GDB 918 can tell whether the stub it is talking to uses the old or the new. */ 919 remcomOutBuffer[0] = 0; 920 break; 921 } 922 putpacket(remcomOutBuffer); 923 } 924} 925 926/********************************** Breakpoint *******************************/ 927/* The hook for both a static (compiled) and a dynamic breakpoint set by GDB. 928 An internal stack is used by the stub. The register image of the caller is 929 stored in the structure register_image. 930 Interactive communication with the host is handled by handle_exception and 931 finally the register image is restored. */ 932 933void kgdb_handle_breakpoint(void); 934 935asm ("\n" 936" .global kgdb_handle_breakpoint\n" 937"kgdb_handle_breakpoint:\n" 938";;\n" 939";; Response to the break-instruction\n" 940";;\n" 941";; Create a register image of the caller\n" 942";;\n" 943" move $dccr,[cris_reg+0x5E] ; Save the flags in DCCR before disable interrupts\n" 944" di ; Disable interrupts\n" 945" move.d $r0,[cris_reg] ; Save R0\n" 946" move.d $r1,[cris_reg+0x04] ; Save R1\n" 947" move.d $r2,[cris_reg+0x08] ; Save R2\n" 948" move.d $r3,[cris_reg+0x0C] ; Save R3\n" 949" move.d $r4,[cris_reg+0x10] ; Save R4\n" 950" move.d $r5,[cris_reg+0x14] ; Save R5\n" 951" move.d $r6,[cris_reg+0x18] ; Save R6\n" 952" move.d $r7,[cris_reg+0x1C] ; Save R7\n" 953" move.d $r8,[cris_reg+0x20] ; Save R8\n" 954" move.d $r9,[cris_reg+0x24] ; Save R9\n" 955" move.d $r10,[cris_reg+0x28] ; Save R10\n" 956" move.d $r11,[cris_reg+0x2C] ; Save R11\n" 957" move.d $r12,[cris_reg+0x30] ; Save R12\n" 958" move.d $r13,[cris_reg+0x34] ; Save R13\n" 959" move.d $sp,[cris_reg+0x38] ; Save SP (R14)\n" 960";; Due to the old assembler-versions BRP might not be recognized\n" 961" .word 0xE670 ; move brp,$r0\n" 962" subq 2,$r0 ; Set to address of previous instruction.\n" 963" move.d $r0,[cris_reg+0x3c] ; Save the address in PC (R15)\n" 964" clear.b [cris_reg+0x40] ; Clear P0\n" 965" move $vr,[cris_reg+0x41] ; Save special register P1\n" 966" clear.w [cris_reg+0x42] ; Clear P4\n" 967" move $ccr,[cris_reg+0x44] ; Save special register CCR\n" 968" move $mof,[cris_reg+0x46] ; P7\n" 969" clear.d [cris_reg+0x4A] ; Clear P8\n" 970" move $ibr,[cris_reg+0x4E] ; P9,\n" 971" move $irp,[cris_reg+0x52] ; P10,\n" 972" move $srp,[cris_reg+0x56] ; P11,\n" 973" move $dtp0,[cris_reg+0x5A] ; P12, register BAR, assembler might not know BAR\n" 974" ; P13, register DCCR already saved\n" 975";; Due to the old assembler-versions BRP might not be recognized\n" 976" .word 0xE670 ; move brp,r0\n" 977";; Static (compiled) breakpoints must return to the next instruction in order\n" 978";; to avoid infinite loops. Dynamic (gdb-invoked) must restore the instruction\n" 979";; in order to execute it when execution is continued.\n" 980" test.b [is_dyn_brkp] ; Is this a dynamic breakpoint?\n" 981" beq is_static ; No, a static breakpoint\n" 982" nop\n" 983" subq 2,$r0 ; rerun the instruction the break replaced\n" 984"is_static:\n" 985" moveq 1,$r1\n" 986" move.b $r1,[is_dyn_brkp] ; Set the state variable to dynamic breakpoint\n" 987" move.d $r0,[cris_reg+0x62] ; Save the return address in BRP\n" 988" move $usp,[cris_reg+0x66] ; USP\n" 989";;\n" 990";; Handle the communication\n" 991";;\n" 992" move.d internal_stack+1020,$sp ; Use the internal stack which grows upward\n" 993" moveq 5,$r10 ; SIGTRAP\n" 994" jsr handle_exception ; Interactive routine\n" 995";;\n" 996";; Return to the caller\n" 997";;\n" 998" move.d [cris_reg],$r0 ; Restore R0\n" 999" move.d [cris_reg+0x04],$r1 ; Restore R1\n" 1000" move.d [cris_reg+0x08],$r2 ; Restore R2\n" 1001" move.d [cris_reg+0x0C],$r3 ; Restore R3\n" 1002" move.d [cris_reg+0x10],$r4 ; Restore R4\n" 1003" move.d [cris_reg+0x14],$r5 ; Restore R5\n" 1004" move.d [cris_reg+0x18],$r6 ; Restore R6\n" 1005" move.d [cris_reg+0x1C],$r7 ; Restore R7\n" 1006" move.d [cris_reg+0x20],$r8 ; Restore R8\n" 1007" move.d [cris_reg+0x24],$r9 ; Restore R9\n" 1008" move.d [cris_reg+0x28],$r10 ; Restore R10\n" 1009" move.d [cris_reg+0x2C],$r11 ; Restore R11\n" 1010" move.d [cris_reg+0x30],$r12 ; Restore R12\n" 1011" move.d [cris_reg+0x34],$r13 ; Restore R13\n" 1012";;\n" 1013";; FIXME: Which registers should be restored?\n" 1014";;\n" 1015" move.d [cris_reg+0x38],$sp ; Restore SP (R14)\n" 1016" move [cris_reg+0x56],$srp ; Restore the subroutine return pointer.\n" 1017" move [cris_reg+0x5E],$dccr ; Restore DCCR\n" 1018" move [cris_reg+0x66],$usp ; Restore USP\n" 1019" jump [cris_reg+0x62] ; A jump to the content in register BRP works.\n" 1020" nop ;\n" 1021"\n"); 1022 1023/* The hook for an interrupt generated by GDB. An internal stack is used 1024 by the stub. The register image of the caller is stored in the structure 1025 register_image. Interactive communication with the host is handled by 1026 handle_exception and finally the register image is restored. Due to the 1027 old assembler which does not recognise the break instruction and the 1028 breakpoint return pointer hex-code is used. */ 1029 1030void kgdb_handle_serial(void); 1031 1032asm ("\n" 1033" .global kgdb_handle_serial\n" 1034"kgdb_handle_serial:\n" 1035";;\n" 1036";; Response to a serial interrupt\n" 1037";;\n" 1038"\n" 1039" move $dccr,[cris_reg+0x5E] ; Save the flags in DCCR\n" 1040" di ; Disable interrupts\n" 1041" move.d $r0,[cris_reg] ; Save R0\n" 1042" move.d $r1,[cris_reg+0x04] ; Save R1\n" 1043" move.d $r2,[cris_reg+0x08] ; Save R2\n" 1044" move.d $r3,[cris_reg+0x0C] ; Save R3\n" 1045" move.d $r4,[cris_reg+0x10] ; Save R4\n" 1046" move.d $r5,[cris_reg+0x14] ; Save R5\n" 1047" move.d $r6,[cris_reg+0x18] ; Save R6\n" 1048" move.d $r7,[cris_reg+0x1C] ; Save R7\n" 1049" move.d $r8,[cris_reg+0x20] ; Save R8\n" 1050" move.d $r9,[cris_reg+0x24] ; Save R9\n" 1051" move.d $r10,[cris_reg+0x28] ; Save R10\n" 1052" move.d $r11,[cris_reg+0x2C] ; Save R11\n" 1053" move.d $r12,[cris_reg+0x30] ; Save R12\n" 1054" move.d $r13,[cris_reg+0x34] ; Save R13\n" 1055" move.d $sp,[cris_reg+0x38] ; Save SP (R14)\n" 1056" move $irp,[cris_reg+0x3c] ; Save the address in PC (R15)\n" 1057" clear.b [cris_reg+0x40] ; Clear P0\n" 1058" move $vr,[cris_reg+0x41] ; Save special register P1,\n" 1059" clear.w [cris_reg+0x42] ; Clear P4\n" 1060" move $ccr,[cris_reg+0x44] ; Save special register CCR\n" 1061" move $mof,[cris_reg+0x46] ; P7\n" 1062" clear.d [cris_reg+0x4A] ; Clear P8\n" 1063" move $ibr,[cris_reg+0x4E] ; P9,\n" 1064" move $irp,[cris_reg+0x52] ; P10,\n" 1065" move $srp,[cris_reg+0x56] ; P11,\n" 1066" move $dtp0,[cris_reg+0x5A] ; P12, register BAR, assembler might not know BAR\n" 1067" ; P13, register DCCR already saved\n" 1068";; Due to the old assembler-versions BRP might not be recognized\n" 1069" .word 0xE670 ; move brp,r0\n" 1070" move.d $r0,[cris_reg+0x62] ; Save the return address in BRP\n" 1071" move $usp,[cris_reg+0x66] ; USP\n" 1072"\n" 1073";; get the serial character (from debugport.c) and check if it is a ctrl-c\n" 1074"\n" 1075" jsr getDebugChar\n" 1076" cmp.b 3, $r10\n" 1077" bne goback\n" 1078" nop\n" 1079"\n" 1080" move.d [cris_reg+0x5E], $r10 ; Get DCCR\n" 1081" btstq 8, $r10 ; Test the U-flag.\n" 1082" bmi goback\n" 1083" nop\n" 1084"\n" 1085";;\n" 1086";; Handle the communication\n" 1087";;\n" 1088" move.d internal_stack+1020,$sp ; Use the internal stack\n" 1089" moveq 2,$r10 ; SIGINT\n" 1090" jsr handle_exception ; Interactive routine\n" 1091"\n" 1092"goback:\n" 1093";;\n" 1094";; Return to the caller\n" 1095";;\n" 1096" move.d [cris_reg],$r0 ; Restore R0\n" 1097" move.d [cris_reg+0x04],$r1 ; Restore R1\n" 1098" move.d [cris_reg+0x08],$r2 ; Restore R2\n" 1099" move.d [cris_reg+0x0C],$r3 ; Restore R3\n" 1100" move.d [cris_reg+0x10],$r4 ; Restore R4\n" 1101" move.d [cris_reg+0x14],$r5 ; Restore R5\n" 1102" move.d [cris_reg+0x18],$r6 ; Restore R6\n" 1103" move.d [cris_reg+0x1C],$r7 ; Restore R7\n" 1104" move.d [cris_reg+0x20],$r8 ; Restore R8\n" 1105" move.d [cris_reg+0x24],$r9 ; Restore R9\n" 1106" move.d [cris_reg+0x28],$r10 ; Restore R10\n" 1107" move.d [cris_reg+0x2C],$r11 ; Restore R11\n" 1108" move.d [cris_reg+0x30],$r12 ; Restore R12\n" 1109" move.d [cris_reg+0x34],$r13 ; Restore R13\n" 1110";;\n" 1111";; FIXME: Which registers should be restored?\n" 1112";;\n" 1113" move.d [cris_reg+0x38],$sp ; Restore SP (R14)\n" 1114" move [cris_reg+0x56],$srp ; Restore the subroutine return pointer.\n" 1115" move [cris_reg+0x5E],$dccr ; Restore DCCR\n" 1116" move [cris_reg+0x66],$usp ; Restore USP\n" 1117" reti ; Return from the interrupt routine\n" 1118" nop\n" 1119"\n"); 1120 1121/* Use this static breakpoint in the start-up only. */ 1122 1123void 1124breakpoint(void) 1125{ 1126 kgdb_started = 1; 1127 is_dyn_brkp = 0; /* This is a static, not a dynamic breakpoint. */ 1128 __asm__ volatile ("break 8"); /* Jump to handle_breakpoint. */ 1129} 1130 1131/* initialize kgdb. doesn't break into the debugger, but sets up irq and ports */ 1132 1133void 1134kgdb_init(void) 1135{ 1136 /* could initialize debug port as well but it's done in head.S already... */ 1137 1138 /* breakpoint handler is now set in irq.c */ 1139 set_int_vector(8, kgdb_handle_serial); 1140 1141 enableDebugIRQ(); 1142} 1143 1144/****************************** End of file **********************************/ 1145