arch/sparc/kernel/sparc-stub.c

   1 /* $Id: sparc-stub.c,v 1.28 2001/10/30 04:54:21 davem Exp $
   2  * sparc-stub.c:  KGDB support for the Linux kernel.
   3  *
   4  * Modifications to run under Linux
   5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   6  *
   7  * This file originally came from the gdb sources, and the
   8  * copyright notices have been retained below.
   9  */
  10
  11 /****************************************************************************
  12
  13                 THIS SOFTWARE IS NOT COPYRIGHTED
  14
  15    HP offers the following for use in the public domain.  HP makes no
  16    warranty with regard to the software or its performance and the
  17    user accepts the software "AS IS" with all faults.
  18
  19    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  20    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  21    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22
  23 ****************************************************************************/
  24
  25 /****************************************************************************
  26  *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
  27  *
  28  *  Module name: remcom.c $
  29  *  Revision: 1.34 $
  30  *  Date: 91/03/09 12:29:49 $
  31  *  Contributor:     Lake Stevens Instrument Division$
  32  *
  33  *  Description:     low level support for gdb debugger. $
  34  *
  35  *  Considerations:  only works on target hardware $
  36  *
  37  *  Written by:      Glenn Engel $
  38  *  ModuleState:     Experimental $
  39  *
  40  *  NOTES:           See Below $
  41  *
  42  *  Modified for SPARC by Stu Grossman, Cygnus Support.
  43  *
  44  *  This code has been extensively tested on the Fujitsu SPARClite demo board.
  45  *
  46  *  To enable debugger support, two things need to happen.  One, a
  47  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  48  *  or error conditions to be properly intercepted and reported to gdb.
  49  *  Two, a breakpoint needs to be generated to begin communication.  This
  50  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  51  *  simulates a breakpoint by executing a trap #1.
  52  *
  53  *************
  54  *
  55  *    The following gdb commands are supported:
  56  *
  57  * command          function                               Return value
  58  *
  59  *    g             return the value of the CPU registers  hex data or ENN
  60  *    G             set the value of the CPU registers     OK or ENN
  61  *
  62  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  63  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  64  *
  65  *    c             Resume at current address              SNN   ( signal NN)
  66  *    cAA..AA       Continue at address AA..AA             SNN
  67  *
  68  *    s             Step one instruction                   SNN
  69  *    sAA..AA       Step one instruction from AA..AA       SNN
  70  *
  71  *    k             kill
  72  *
  73  *    ?             What was the last sigval ?             SNN   (signal NN)
  74  *
  75  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
  76  *                                                         baud rate
  77  *
  78  * All commands and responses are sent with a packet which includes a
  79  * checksum.  A packet consists of
  80  *
  81  * $<packet info>#<checksum>.
  82  *
  83  * where
  84  * <packet info> :: <characters representing the command or response>
  85  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
  86  *
  87  * When a packet is received, it is first acknowledged with either '+' or '-'.
  88  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  89  *
  90  * Example:
  91  *
  92  * Host:                  Reply:
  93  * $m0,10#2a               +$00010203040506070809101112131415#42
  94  *
  95  ****************************************************************************/
  96
  97 #include <linux/kernel.h>
  98 #include <linux/string.h>
  99 #include <linux/mm.h>
 100 #include <linux/smp.h>
 101 #include <linux/smp_lock.h>
 102
 103 #include <asm/system.h>
 104 #include <asm/signal.h>
 105 #include <asm/oplib.h>
 106 #include <asm/head.h>
 107 #include <asm/traps.h>
 108 #include <asm/vac-ops.h>
 109 #include <asm/kgdb.h>
 110 #include <asm/pgalloc.h>
 111 #include <asm/pgtable.h>
 112 #include <asm/cacheflush.h>
 113
 114 /*
 115  *
 116  * external low-level support routines
 117  */
 118
 119 extern void putDebugChar(char);   /* write a single character      */
 120 extern char getDebugChar(void);   /* read and return a single char */
 121
 122 /*
 123  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
 124  * at least NUMREGBYTES*2 are needed for register packets
 125  */
 126 #define BUFMAX 2048
 127
 128 static int initialized; /* !0 means we've been initialized */
 129
 130 static const char hexchars[]="0123456789abcdef";
 131
 132 #define NUMREGS 72
 133
 134 /* Number of bytes of registers.  */
 135 #define NUMREGBYTES (NUMREGS * 4)
 136 enum regnames {G0, G1, G2, G3, G4, G5, G6, G7,
 137                  O0, O1, O2, O3, O4, O5, SP, O7,
 138                  L0, L1, L2, L3, L4, L5, L6, L7,
 139                  I0, I1, I2, I3, I4, I5, FP, I7,
 140
 141                  F0, F1, F2, F3, F4, F5, F6, F7,
 142                  F8, F9, F10, F11, F12, F13, F14, F15,
 143                  F16, F17, F18, F19, F20, F21, F22, F23,
 144                  F24, F25, F26, F27, F28, F29, F30, F31,
 145                  Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR };
 146
 147
 148 extern void trap_low(void);  /* In arch/sparc/kernel/entry.S */
 149
 150 unsigned long get_sun4cpte(unsigned long addr)
 151 {
 152         unsigned long entry;
 153
 154         __asm__ __volatile__("\n\tlda [%1] %2, %0\n\t" :
 155                              "=r" (entry) :
 156                              "r" (addr), "i" (ASI_PTE));
 157         return entry;
 158 }
 159
 160 unsigned long get_sun4csegmap(unsigned long addr)
 161 {
 162         unsigned long entry;
 163
 164         __asm__ __volatile__("\n\tlduba [%1] %2, %0\n\t" :
 165                              "=r" (entry) :
 166                              "r" (addr), "i" (ASI_SEGMAP));
 167         return entry;
 168 }
 169
 170 #if 0
 171 /* Have to sort this out. This cannot be done after initialization. */
 172 static void flush_cache_all_nop(void) {}
 173 #endif
 174
 175 /* Place where we save old trap entries for restoration */
 176 struct tt_entry kgdb_savettable[256];
 177 typedef void (*trapfunc_t)(void);
 178
 179 /* Helper routine for manipulation of kgdb_savettable */
 180 static inline void copy_ttentry(struct tt_entry *src, struct tt_entry *dest)
 181 {
 182         dest->inst_one = src->inst_one;
 183         dest->inst_two = src->inst_two;
 184         dest->inst_three = src->inst_three;
 185         dest->inst_four = src->inst_four;
 186 }
 187
 188 /* Initialize the kgdb_savettable so that debugging can commence */
 189 static void eh_init(void)
 190 {
 191         int i;
 192
 193         for(i=0; i < 256; i++)
 194                 copy_ttentry(&sparc_ttable[i], &kgdb_savettable[i]);
 195 }
 196
 197 /* Install an exception handler for kgdb */
 198 static void exceptionHandler(int tnum, trapfunc_t trap_entry)
 199 {
 200         unsigned long te_addr = (unsigned long) trap_entry;
 201
 202         /* Make new vector */
 203         sparc_ttable[tnum].inst_one =
 204                 SPARC_BRANCH((unsigned long) te_addr,
 205                              (unsigned long) &sparc_ttable[tnum].inst_one);
 206         sparc_ttable[tnum].inst_two = SPARC_RD_PSR_L0;
 207         sparc_ttable[tnum].inst_three = SPARC_NOP;
 208         sparc_ttable[tnum].inst_four = SPARC_NOP;
 209 }
 210
 211 /* Convert ch from a hex digit to an int */
 212 static int
 213 hex(unsigned char ch)
 214 {
 215         if (ch >= 'a' && ch <= 'f')
 216                 return ch-'a'+10;
 217         if (ch >= '0' && ch <= '9')
 218                 return ch-'0';
 219         if (ch >= 'A' && ch <= 'F')
 220                 return ch-'A'+10;
 221         return -1;
 222 }
 223
 224 /* scan for the sequence $<data>#<checksum>     */
 225 static void
 226 getpacket(char *buffer)
 227 {
 228         unsigned char checksum;
 229         unsigned char xmitcsum;
 230         int i;
 231         int count;
 232         unsigned char ch;
 233
 234         do {
 235                 /* wait around for the start character, ignore all other characters */
 236                 while ((ch = (getDebugChar() & 0x7f)) != '$') ;
 237
 238                 checksum = 0;
 239                 xmitcsum = -1;
 240
 241                 count = 0;
 242
 243                 /* now, read until a # or end of buffer is found */
 244                 while (count < BUFMAX) {
 245                         ch = getDebugChar() & 0x7f;
 246                         if (ch == '#')
 247                                 break;
 248                         checksum = checksum + ch;
 249                         buffer[count] = ch;
 250                         count = count + 1;
 251                 }
 252
 253                 if (count >= BUFMAX)
 254                         continue;
 255
 256                 buffer[count] = 0;
 257
 258                 if (ch == '#') {
 259                         xmitcsum = hex(getDebugChar() & 0x7f) << 4;
 260                         xmitcsum |= hex(getDebugChar() & 0x7f);
 261                         if (checksum != xmitcsum)
 262                                 putDebugChar('-');      /* failed checksum */
 263                         else {
 264                                 putDebugChar('+'); /* successful transfer */
 265                                 /* if a sequence char is present, reply the ID */
 266                                 if (buffer[2] == ':') {
 267                                         putDebugChar(buffer[0]);
 268                                         putDebugChar(buffer[1]);
 269                                         /* remove sequence chars from buffer */
 270                                         count = strlen(buffer);
 271                                         for (i=3; i <= count; i++)
 272                                                 buffer[i-3] = buffer[i];
 273                                 }
 274                         }
 275                 }
 276         } while (checksum != xmitcsum);
 277 }
 278
 279 /* send the packet in buffer.  */
 280
 281 static void
 282 putpacket(unsigned char *buffer)
 283 {
 284         unsigned char checksum;
 285         int count;
 286         unsigned char ch, recv;
 287
 288         /*  $<packet info>#<checksum>. */
 289         do {
 290                 putDebugChar('$');
 291                 checksum = 0;
 292                 count = 0;
 293
 294                 while ((ch = buffer[count])) {
 295                         putDebugChar(ch);
 296                         checksum += ch;
 297                         count += 1;
 298                 }
 299
 300                 putDebugChar('#');
 301                 putDebugChar(hexchars[checksum >> 4]);
 302                 putDebugChar(hexchars[checksum & 0xf]);
 303                 recv = getDebugChar();
 304         } while ((recv & 0x7f) != '+');
 305 }
 306
 307 static char remcomInBuffer[BUFMAX];
 308 static char remcomOutBuffer[BUFMAX];
 309
 310 /* Convert the memory pointed to by mem into hex, placing result in buf.
 311  * Return a pointer to the last char put in buf (null), in case of mem fault,
 312  * return 0.
 313  */
 314
 315 static unsigned char *
 316 mem2hex(char *mem, char *buf, int count)
 317 {
 318         unsigned char ch;
 319
 320         while (count-- > 0) {
 321                 /* This assembler code is basically:  ch = *mem++;
 322                  * except that we use the SPARC/Linux exception table
 323                  * mechanism (see how "fixup" works in kernel_mna_trap_fault)
 324                  * to arrange for a "return 0" upon a memory fault
 325                  */
 326                 __asm__(
 327                         "\n1:\n\t"
 328                         "ldub [%0], %1\n\t"
 329                         "inc %0\n\t"
 330                         ".section .fixup,#alloc,#execinstr\n\t"
 331                         ".align 4\n"
 332                         "2:\n\t"
 333                         "retl\n\t"
 334                         " mov 0, %%o0\n\t"
 335                         ".section __ex_table, #alloc\n\t"
 336                         ".align 4\n\t"
 337                         ".word 1b, 2b\n\t"
 338                         ".text\n"
 339                         : "=r" (mem), "=r" (ch) : "0" (mem));
 340                 *buf++ = hexchars[ch >> 4];
 341                 *buf++ = hexchars[ch & 0xf];
 342         }
 343
 344         *buf = 0;
 345         return buf;
 346 }
 347
 348 /* convert the hex array pointed to by buf into binary to be placed in mem
 349  * return a pointer to the character AFTER the last byte written.
 350 */
 351 static char *
 352 hex2mem(char *buf, char *mem, int count)
 353 {
 354         int i;
 355         unsigned char ch;
 356
 357         for (i=0; i<count; i++) {
 358
 359                 ch = hex(*buf++) << 4;
 360                 ch |= hex(*buf++);
 361                 /* Assembler code is   *mem++ = ch;   with return 0 on fault */
 362                 __asm__(
 363                         "\n1:\n\t"
 364                         "stb %1, [%0]\n\t"
 365                         "inc %0\n\t"
 366                         ".section .fixup,#alloc,#execinstr\n\t"
 367                         ".align 4\n"
 368                         "2:\n\t"
 369                         "retl\n\t"
 370                         " mov 0, %%o0\n\t"
 371                         ".section __ex_table, #alloc\n\t"
 372                         ".align 4\n\t"
 373                         ".word 1b, 2b\n\t"
 374                         ".text\n"
 375                         : "=r" (mem) : "r" (ch) , "0" (mem));
 376         }
 377         return mem;
 378 }
 379
 380 /* This table contains the mapping between SPARC hardware trap types, and
 381    signals, which are primarily what GDB understands.  It also indicates
 382    which hardware traps we need to commandeer when initializing the stub. */
 383
 384 static struct hard_trap_info
 385 {
 386   unsigned char tt;             /* Trap type code for SPARC */
 387   unsigned char signo;          /* Signal that we map this trap into */
 388 } hard_trap_info[] = {
 389   {SP_TRAP_SBPT, SIGTRAP},      /* ta 1 - Linux/KGDB software breakpoint */
 390   {0, 0}                        /* Must be last */
 391 };
 392
 393 /* Set up exception handlers for tracing and breakpoints */
 394
 395 void
 396 set_debug_traps(void)
 397 {
 398         struct hard_trap_info *ht;
 399         unsigned long flags;
 400
 401         local_irq_save(flags);
 402 #if 0
 403 /* Have to sort this out. This cannot be done after initialization. */
 404         BTFIXUPSET_CALL(flush_cache_all, flush_cache_all_nop, BTFIXUPCALL_NOP);
 405 #endif
 406
 407         /* Initialize our copy of the Linux Sparc trap table */
 408         eh_init();
 409
 410         for (ht = hard_trap_info; ht->tt && ht->signo; ht++) {
 411                 /* Only if it doesn't destroy our fault handlers */
 412                 if((ht->tt != SP_TRAP_TFLT) &&
 413                    (ht->tt != SP_TRAP_DFLT))
 414                         exceptionHandler(ht->tt, trap_low);
 415         }
 416
 417         /* In case GDB is started before us, ack any packets (presumably
 418          * "$?#xx") sitting there.
 419          *
 420          * I've found this code causes more problems than it solves,
 421          * so that's why it's commented out.  GDB seems to work fine
 422          * now starting either before or after the kernel   -bwb
 423          */
 424 #if 0
 425         while((c = getDebugChar()) != '$');
 426         while((c = getDebugChar()) != '#');
 427         c = getDebugChar(); /* eat first csum byte */
 428         c = getDebugChar(); /* eat second csum byte */
 429         putDebugChar('+'); /* ack it */
 430 #endif
 431
 432         initialized = 1; /* connect! */
 433         local_irq_restore(flags);
 434 }
 435
 436 /* Convert the SPARC hardware trap type code to a unix signal number. */
 437
 438 static int
 439 computeSignal(int tt)
 440 {
 441         struct hard_trap_info *ht;
 442
 443         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
 444                 if (ht->tt == tt)
 445                         return ht->signo;
 446
 447         return SIGHUP;         /* default for things we don't know about */
 448 }
 449
 450 /*
 451  * While we find nice hex chars, build an int.
 452  * Return number of chars processed.
 453  */
 454
 455 static int
 456 hexToInt(char **ptr, int *intValue)
 457 {
 458         int numChars = 0;
 459         int hexValue;
 460
 461         *intValue = 0;
 462
 463         while (**ptr) {
 464                 hexValue = hex(**ptr);
 465                 if (hexValue < 0)
 466                         break;
 467
 468                 *intValue = (*intValue << 4) | hexValue;
 469                 numChars ++;
 470
 471                 (*ptr)++;
 472         }
 473
 474         return (numChars);
 475 }
 476
 477 /*
 478  * This function does all command processing for interfacing to gdb.  It
 479  * returns 1 if you should skip the instruction at the trap address, 0
 480  * otherwise.
 481  */
 482
 483 extern void breakinst(void);
 484
 485 void
 486 handle_exception (unsigned long *registers)
 487 {
 488         int tt;       /* Trap type */
 489         int sigval;
 490         int addr;
 491         int length;
 492         char *ptr;
 493         unsigned long *sp;
 494
 495         /* First, we must force all of the windows to be spilled out */
 496
 497         asm("save %sp, -64, %sp\n\t"
 498             "save %sp, -64, %sp\n\t"
 499             "save %sp, -64, %sp\n\t"
 500             "save %sp, -64, %sp\n\t"
 501             "save %sp, -64, %sp\n\t"
 502             "save %sp, -64, %sp\n\t"
 503             "save %sp, -64, %sp\n\t"
 504             "save %sp, -64, %sp\n\t"
 505             "restore\n\t"
 506             "restore\n\t"
 507             "restore\n\t"
 508             "restore\n\t"
 509             "restore\n\t"
 510             "restore\n\t"
 511             "restore\n\t"
 512             "restore\n\t");
 513
 514         lock_kernel();
 515         if (registers[PC] == (unsigned long)breakinst) {
 516                 /* Skip over breakpoint trap insn */
 517                 registers[PC] = registers[NPC];
 518                 registers[NPC] += 4;
 519         }
 520
 521         sp = (unsigned long *)registers[SP];
 522
 523         tt = (registers[TBR] >> 4) & 0xff;
 524
 525         /* reply to host that an exception has occurred */
 526         sigval = computeSignal(tt);
 527         ptr = remcomOutBuffer;
 528
 529         *ptr++ = 'T';
 530         *ptr++ = hexchars[sigval >> 4];
 531         *ptr++ = hexchars[sigval & 0xf];
 532
 533         *ptr++ = hexchars[PC >> 4];
 534         *ptr++ = hexchars[PC & 0xf];
 535         *ptr++ = ':';
 536         ptr = mem2hex((char *)&registers[PC], ptr, 4);
 537         *ptr++ = ';';
 538
 539         *ptr++ = hexchars[FP >> 4];
 540         *ptr++ = hexchars[FP & 0xf];
 541         *ptr++ = ':';
 542         ptr = mem2hex((char *) (sp + 8 + 6), ptr, 4); /* FP */
 543         *ptr++ = ';';
 544
 545         *ptr++ = hexchars[SP >> 4];
 546         *ptr++ = hexchars[SP & 0xf];
 547         *ptr++ = ':';
 548         ptr = mem2hex((char *)&sp, ptr, 4);
 549         *ptr++ = ';';
 550
 551         *ptr++ = hexchars[NPC >> 4];
 552         *ptr++ = hexchars[NPC & 0xf];
 553         *ptr++ = ':';
 554         ptr = mem2hex((char *)&registers[NPC], ptr, 4);
 555         *ptr++ = ';';
 556
 557         *ptr++ = hexchars[O7 >> 4];
 558         *ptr++ = hexchars[O7 & 0xf];
 559         *ptr++ = ':';
 560         ptr = mem2hex((char *)&registers[O7], ptr, 4);
 561         *ptr++ = ';';
 562
 563         *ptr++ = 0;
 564
 565         putpacket(remcomOutBuffer);
 566
 567         /* XXX We may want to add some features dealing with poking the
 568          * XXX page tables, the real ones on the srmmu, and what is currently
 569          * XXX loaded in the sun4/sun4c tlb at this point in time.  But this
 570          * XXX also required hacking to the gdb sources directly...
 571          */
 572
 573         while (1) {
 574                 remcomOutBuffer[0] = 0;
 575
 576                 getpacket(remcomInBuffer);
 577                 switch (remcomInBuffer[0]) {
 578                 case '?':
 579                         remcomOutBuffer[0] = 'S';
 580                         remcomOutBuffer[1] = hexchars[sigval >> 4];
 581                         remcomOutBuffer[2] = hexchars[sigval & 0xf];
 582                         remcomOutBuffer[3] = 0;
 583                         break;
 584
 585                 case 'd':
 586                         /* toggle debug flag */
 587                         break;
 588
 589                 case 'g':               /* return the value of the CPU registers */
 590                 {
 591                         ptr = remcomOutBuffer;
 592                         /* G & O regs */
 593                         ptr = mem2hex((char *)registers, ptr, 16 * 4);
 594                         /* L & I regs */
 595                         ptr = mem2hex((char *) (sp + 0), ptr, 16 * 4);
 596                         /* Floating point */
 597                         memset(ptr, '0', 32 * 8);
 598                         /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 599                         mem2hex((char *)&registers[Y], (ptr + 32 * 4 * 2), (8 * 4));
 600                 }
 601                         break;
 602
 603                 case 'G':          /* set the value of the CPU registers - return OK */
 604                 {
 605                         unsigned long *newsp, psr;
 606
 607                         psr = registers[PSR];
 608
 609                         ptr = &remcomInBuffer[1];
 610                         /* G & O regs */
 611                         hex2mem(ptr, (char *)registers, 16 * 4);
 612                         /* L & I regs */
 613                         hex2mem(ptr + 16 * 4 * 2, (char *) (sp + 0), 16 * 4);
 614                         /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 615                         hex2mem(ptr + 64 * 4 * 2, (char *)&registers[Y], 8 * 4);
 616
 617                         /* See if the stack pointer has moved.  If so,
 618                          * then copy the saved locals and ins to the
 619                          * new location.  This keeps the window
 620                          * overflow and underflow routines happy.
 621                          */
 622
 623                         newsp = (unsigned long *)registers[SP];
 624                         if (sp != newsp)
 625                                 sp = memcpy(newsp, sp, 16 * 4);
 626
 627                         /* Don't allow CWP to be modified. */
 628
 629                         if (psr != registers[PSR])
 630                                 registers[PSR] = (psr & 0x1f) | (registers[PSR] & ~0x1f);
 631
 632                         strcpy(remcomOutBuffer,"OK");
 633                 }
 634                         break;
 635
 636                 case 'm':         /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 637                         /* Try to read %x,%x.  */
 638
 639                         ptr = &remcomInBuffer[1];
 640
 641                         if (hexToInt(&ptr, &addr)
 642                             && *ptr++ == ','
 643                             && hexToInt(&ptr, &length)) {
 644                                 if (mem2hex((char *)addr, remcomOutBuffer, length))
 645                                         break;
 646
 647                                 strcpy (remcomOutBuffer, "E03");
 648                         } else {
 649                                 strcpy(remcomOutBuffer,"E01");
 650                         }
 651                         break;
 652
 653                 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 654                         /* Try to read '%x,%x:'.  */
 655
 656                         ptr = &remcomInBuffer[1];
 657
 658                         if (hexToInt(&ptr, &addr)
 659                             && *ptr++ == ','
 660                             && hexToInt(&ptr, &length)
 661                             && *ptr++ == ':') {
 662                                 if (hex2mem(ptr, (char *)addr, length)) {
 663                                         strcpy(remcomOutBuffer, "OK");
 664                                 } else {
 665                                         strcpy(remcomOutBuffer, "E03");
 666                                 }
 667                         } else {
 668                                 strcpy(remcomOutBuffer, "E02");
 669                         }
 670                         break;
 671
 672                 case 'c':    /* cAA..AA    Continue at address AA..AA(optional) */
 673                         /* try to read optional parameter, pc unchanged if no parm */
 674
 675                         ptr = &remcomInBuffer[1];
 676                         if (hexToInt(&ptr, &addr)) {
 677                                 registers[PC] = addr;
 678                                 registers[NPC] = addr + 4;
 679                         }
 680
 681 /* Need to flush the instruction cache here, as we may have deposited a
 682  * breakpoint, and the icache probably has no way of knowing that a data ref to
 683  * some location may have changed something that is in the instruction cache.
 684  */
 685                         flush_cache_all();
 686                         unlock_kernel();
 687                         return;
 688
 689                         /* kill the program */
 690                 case 'k' :              /* do nothing */
 691                         break;
 692                 case 'r':               /* Reset */
 693                         asm ("call 0\n\t"
 694                              "nop\n\t");
 695                         break;
 696                 }                       /* switch */
 697
 698                 /* reply to the request */
 699                 putpacket(remcomOutBuffer);
 700         } /* while(1) */
 701 }
 702
 703 /* This function will generate a breakpoint exception.  It is used at the
 704    beginning of a program to sync up with a debugger and can be used
 705    otherwise as a quick means to stop program execution and "break" into
 706    the debugger. */
 707
 708 void
 709 breakpoint(void)
 710 {
 711         if (!initialized)
 712                 return;
 713
 714         /* Again, watch those c-prefixes for ELF kernels */
 715 #if defined(__svr4__) || defined(__ELF__)
 716         asm(".globl breakinst\n"
 717             "breakinst:\n\t"
 718             "ta 1\n");
 719 #else
 720         asm(".globl _breakinst\n"
 721             "_breakinst:\n\t"
 722             "ta 1\n");
 723 #endif
 724 }