linux/arch/cris/arch-v10/kernel/kgdb.c
<<
>>
Prefs
   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/************** Prototypes for local library functions ***********************/
 234
 235/* Copy of strcpy from libc. */
 236static char *gdb_cris_strcpy (char *s1, const char *s2);
 237
 238/* Copy of strlen from libc. */
 239static int gdb_cris_strlen (const char *s);
 240
 241/* Copy of memchr from libc. */
 242static void *gdb_cris_memchr (const void *s, int c, int n);
 243
 244/* Copy of strtol from libc. Does only support base 16. */
 245static int gdb_cris_strtol (const char *s, char **endptr, int base);
 246
 247/********************** Prototypes for local functions. **********************/
 248/* Copy the content of a register image into another. The size n is
 249   the size of the register image. Due to struct assignment generation of
 250   memcpy in libc. */
 251static void copy_registers (registers *dptr, registers *sptr, int n);
 252
 253/* Copy the stored registers from the stack. Put the register contents
 254   of thread thread_id in the struct reg. */
 255static void copy_registers_from_stack (int thread_id, registers *reg);
 256
 257/* Copy the registers to the stack. Put the register contents of thread
 258   thread_id from struct reg to the stack. */
 259static void copy_registers_to_stack (int thread_id, registers *reg);
 260
 261/* Write a value to a specified register regno in the register image
 262   of the current thread. */
 263static int write_register (int regno, char *val);
 264
 265/* Write a value to a specified register in the stack of a thread other
 266   than the current thread. */
 267static write_stack_register (int thread_id, int regno, char *valptr);
 268
 269/* Read a value from a specified register in the register image. Returns the
 270   status of the read operation. The register value is returned in valptr. */
 271static int read_register (char regno, unsigned int *valptr);
 272
 273/* Serial port, reads one character. ETRAX 100 specific. from debugport.c */
 274int getDebugChar (void);
 275
 276/* Serial port, writes one character. ETRAX 100 specific. from debugport.c */
 277void putDebugChar (int val);
 278
 279void enableDebugIRQ (void);
 280
 281/* Returns the integer equivalent of a hexadecimal character. */
 282static int hex (char ch);
 283
 284/* Convert the memory, pointed to by mem into hexadecimal representation.
 285   Put the result in buf, and return a pointer to the last character
 286   in buf (null). */
 287static char *mem2hex (char *buf, unsigned char *mem, int count);
 288
 289/* Convert the array, in hexadecimal representation, pointed to by buf into
 290   binary representation. Put the result in mem, and return a pointer to
 291   the character after the last byte written. */
 292static unsigned char *hex2mem (unsigned char *mem, char *buf, int count);
 293
 294/* Put the content of the array, in binary representation, pointed to by buf
 295   into memory pointed to by mem, and return a pointer to
 296   the character after the last byte written. */
 297static unsigned char *bin2mem (unsigned char *mem, unsigned char *buf, int count);
 298
 299/* Await the sequence $<data>#<checksum> and store <data> in the array buffer
 300   returned. */
 301static void getpacket (char *buffer);
 302
 303/* Send $<data>#<checksum> from the <data> in the array buffer. */
 304static void putpacket (char *buffer);
 305
 306/* Build and send a response packet in order to inform the host the
 307   stub is stopped. */
 308static void stub_is_stopped (int sigval);
 309
 310/* All expected commands are sent from remote.c. Send a response according
 311   to the description in remote.c. */
 312static void handle_exception (int sigval);
 313
 314/* Performs a complete re-start from scratch. ETRAX specific. */
 315static void kill_restart (void);
 316
 317/******************** Prototypes for global functions. ***********************/
 318
 319/* The string str is prepended with the GDB printout token and sent. */
 320void putDebugString (const unsigned char *str, int length); /* used by etrax100ser.c */
 321
 322/* The hook for both static (compiled) and dynamic breakpoints set by GDB.
 323   ETRAX 100 specific. */
 324void handle_breakpoint (void);                          /* used by irq.c */
 325
 326/* The hook for an interrupt generated by GDB. ETRAX 100 specific. */
 327void handle_interrupt (void);                           /* used by irq.c */
 328
 329/* A static breakpoint to be used at startup. */
 330void breakpoint (void);                                 /* called by init/main.c */
 331
 332/* From osys_int.c, executing_task contains the number of the current
 333   executing task in osys. Does not know of object-oriented threads. */
 334extern unsigned char executing_task;
 335
 336/* The number of characters used for a 64 bit thread identifier. */
 337#define HEXCHARS_IN_THREAD_ID 16
 338
 339/* Avoid warning as the internal_stack is not used in the C-code. */
 340#define USEDVAR(name)    { if (name) { ; } }
 341#define USEDFUN(name) { void (*pf)(void) = (void *)name; USEDVAR(pf) }
 342
 343/********************************** Packet I/O ******************************/
 344/* BUFMAX defines the maximum number of characters in
 345   inbound/outbound buffers */
 346#define BUFMAX 512
 347
 348/* Run-length encoding maximum length. Send 64 at most. */
 349#define RUNLENMAX 64
 350
 351/* The inbound/outbound buffers used in packet I/O */
 352static char remcomInBuffer[BUFMAX];
 353static char remcomOutBuffer[BUFMAX];
 354
 355/* Error and warning messages. */
 356enum error_type
 357{
 358        SUCCESS, E01, E02, E03, E04, E05, E06, E07
 359};
 360static char *error_message[] =
 361{
 362        "",
 363        "E01 Set current or general thread - H[c,g] - internal error.",
 364        "E02 Change register content - P - cannot change read-only register.",
 365        "E03 Thread is not alive.", /* T, not used. */
 366        "E04 The command is not supported - [s,C,S,!,R,d,r] - internal error.",
 367        "E05 Change register content - P - the register is not implemented..",
 368        "E06 Change memory content - M - internal error.",
 369        "E07 Change register content - P - the register is not stored on the stack"
 370};
 371/********************************* Register image ****************************/
 372/* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's
 373   Reference", p. 1-1, with the additional register definitions of the
 374   ETRAX 100LX in cris-opc.h.
 375   There are 16 general 32-bit registers, R0-R15, where R14 is the stack
 376   pointer, SP, and R15 is the program counter, PC.
 377   There are 16 special registers, P0-P15, where three of the unimplemented
 378   registers, P0, P4 and P8, are reserved as zero-registers. A read from
 379   any of these registers returns zero and a write has no effect. */
 380enum register_name
 381{
 382        R0,  R1,   R2,  R3,
 383        R4,  R5,   R6,  R7,
 384        R8,  R9,   R10, R11,
 385        R12, R13,  SP,  PC,
 386        P0,  VR,   P2,  P3,
 387        P4,  CCR,  P6,  MOF,
 388        P8,  IBR,  IRP, SRP,
 389        BAR, DCCR, BRP, USP
 390};
 391
 392/* The register sizes of the registers in register_name. An unimplemented register
 393   is designated by size 0 in this array. */
 394static int register_size[] =
 395{
 396        4, 4, 4, 4,
 397        4, 4, 4, 4,
 398        4, 4, 4, 4,
 399        4, 4, 4, 4,
 400        1, 1, 0, 0,
 401        2, 2, 0, 4,
 402        4, 4, 4, 4,
 403        4, 4, 4, 4
 404};
 405
 406/* Contains the register image of the executing thread in the assembler
 407   part of the code in order to avoid horrible addressing modes. */
 408static registers reg;
 409
 410/* FIXME: Should this be used? Delete otherwise. */
 411/* Contains the assumed consistency state of the register image. Uses the
 412   enum error_type for state information. */
 413static int consistency_status = SUCCESS;
 414
 415/********************************** Handle exceptions ************************/
 416/* The variable reg contains the register image associated with the
 417   current_thread_c variable. It is a complete register image created at
 418   entry. The reg_g contains a register image of a task where the general
 419   registers are taken from the stack and all special registers are taken
 420   from the executing task. It is associated with current_thread_g and used
 421   in order to provide access mainly for 'g', 'G' and 'P'.
 422*/
 423
 424/* Need two task id pointers in order to handle Hct and Hgt commands. */
 425static int current_thread_c = 0;
 426static int current_thread_g = 0;
 427
 428/* Need two register images in order to handle Hct and Hgt commands. The
 429   variable reg_g is in addition to reg above. */
 430static registers reg_g;
 431
 432/********************************** Breakpoint *******************************/
 433/* Use an internal stack in the breakpoint and interrupt response routines */
 434#define INTERNAL_STACK_SIZE 1024
 435static char internal_stack[INTERNAL_STACK_SIZE];
 436
 437/* Due to the breakpoint return pointer, a state variable is needed to keep
 438   track of whether it is a static (compiled) or dynamic (gdb-invoked)
 439   breakpoint to be handled. A static breakpoint uses the content of register
 440   BRP as it is whereas a dynamic breakpoint requires subtraction with 2
 441   in order to execute the instruction. The first breakpoint is static. */
 442static unsigned char is_dyn_brkp = 0;
 443
 444/********************************* String library ****************************/
 445/* Single-step over library functions creates trap loops. */
 446
 447/* Copy char s2[] to s1[]. */
 448static char*
 449gdb_cris_strcpy (char *s1, const char *s2)
 450{
 451        char *s = s1;
 452        
 453        for (s = s1; (*s++ = *s2++) != '\0'; )
 454                ;
 455        return (s1);
 456}
 457
 458/* Find length of s[]. */
 459static int
 460gdb_cris_strlen (const char *s)
 461{
 462        const char *sc;
 463        
 464        for (sc = s; *sc != '\0'; sc++)
 465                ;
 466        return (sc - s);
 467}
 468
 469/* Find first occurrence of c in s[n]. */
 470static void*
 471gdb_cris_memchr (const void *s, int c, int n)
 472{
 473        const unsigned char uc = c;
 474        const unsigned char *su;
 475        
 476        for (su = s; 0 < n; ++su, --n)
 477                if (*su == uc)
 478                        return ((void *)su);
 479        return (NULL);
 480}
 481/******************************* Standard library ****************************/
 482/* Single-step over library functions creates trap loops. */
 483/* Convert string to long. */
 484static int
 485gdb_cris_strtol (const char *s, char **endptr, int base)
 486{
 487        char *s1;
 488        char *sd;
 489        int x = 0;
 490        
 491        for (s1 = (char*)s; (sd = gdb_cris_memchr(hex_asc, *s1, base)) != NULL; ++s1)
 492                x = x * base + (sd - hex_asc);
 493        
 494        if (endptr)
 495        {
 496                /* Unconverted suffix is stored in endptr unless endptr is NULL. */
 497                *endptr = s1;
 498        }
 499        
 500        return x;
 501}
 502
 503/********************************* Register image ****************************/
 504/* Copy the content of a register image into another. The size n is
 505   the size of the register image. Due to struct assignment generation of
 506   memcpy in libc. */
 507static void
 508copy_registers (registers *dptr, registers *sptr, int n)
 509{
 510        unsigned char *dreg;
 511        unsigned char *sreg;
 512        
 513        for (dreg = (unsigned char*)dptr, sreg = (unsigned char*)sptr; n > 0; n--)
 514                *dreg++ = *sreg++;
 515}
 516
 517#ifdef PROCESS_SUPPORT
 518/* Copy the stored registers from the stack. Put the register contents
 519   of thread thread_id in the struct reg. */
 520static void
 521copy_registers_from_stack (int thread_id, registers *regptr)
 522{
 523        int j;
 524        stack_registers *s = (stack_registers *)stack_list[thread_id];
 525        unsigned int *d = (unsigned int *)regptr;
 526        
 527        for (j = 13; j >= 0; j--)
 528                *d++ = s->r[j];
 529        regptr->sp = (unsigned int)stack_list[thread_id];
 530        regptr->pc = s->pc;
 531        regptr->dccr = s->dccr;
 532        regptr->srp = s->srp;
 533}
 534
 535/* Copy the registers to the stack. Put the register contents of thread
 536   thread_id from struct reg to the stack. */
 537static void
 538copy_registers_to_stack (int thread_id, registers *regptr)
 539{
 540        int i;
 541        stack_registers *d = (stack_registers *)stack_list[thread_id];
 542        unsigned int *s = (unsigned int *)regptr;
 543        
 544        for (i = 0; i < 14; i++) {
 545                d->r[i] = *s++;
 546        }
 547        d->pc = regptr->pc;
 548        d->dccr = regptr->dccr;
 549        d->srp = regptr->srp;
 550}
 551#endif
 552
 553/* Write a value to a specified register in the register image of the current
 554   thread. Returns status code SUCCESS, E02 or E05. */
 555static int
 556write_register (int regno, char *val)
 557{
 558        int status = SUCCESS;
 559        registers *current_reg = &reg;
 560
 561        if (regno >= R0 && regno <= PC) {
 562                /* 32-bit register with simple offset. */
 563                hex2mem ((unsigned char *)current_reg + regno * sizeof(unsigned int),
 564                         val, sizeof(unsigned int));
 565        }
 566        else if (regno == P0 || regno == VR || regno == P4 || regno == P8) {
 567                /* Do not support read-only registers. */
 568                status = E02;
 569        }
 570        else if (regno == CCR) {
 571                /* 16 bit register with complex offset. (P4 is read-only, P6 is not implemented, 
 572                   and P7 (MOF) is 32 bits in ETRAX 100LX. */
 573                hex2mem ((unsigned char *)&(current_reg->ccr) + (regno-CCR) * sizeof(unsigned short),
 574                         val, sizeof(unsigned short));
 575        }
 576        else if (regno >= MOF && regno <= USP) {
 577                /* 32 bit register with complex offset.  (P8 has been taken care of.) */
 578                hex2mem ((unsigned char *)&(current_reg->ibr) + (regno-IBR) * sizeof(unsigned int),
 579                         val, sizeof(unsigned int));
 580        } 
 581        else {
 582                /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
 583                status = E05;
 584        }
 585        return status;
 586}
 587
 588#ifdef PROCESS_SUPPORT
 589/* Write a value to a specified register in the stack of a thread other
 590   than the current thread. Returns status code SUCCESS or E07. */
 591static int
 592write_stack_register (int thread_id, int regno, char *valptr)
 593{
 594        int status = SUCCESS;
 595        stack_registers *d = (stack_registers *)stack_list[thread_id];
 596        unsigned int val;
 597        
 598        hex2mem ((unsigned char *)&val, valptr, sizeof(unsigned int));
 599        if (regno >= R0 && regno < SP) {
 600                d->r[regno] = val;
 601        }
 602        else if (regno == SP) {
 603                stack_list[thread_id] = val;
 604        }
 605        else if (regno == PC) {
 606                d->pc = val;
 607        }
 608        else if (regno == SRP) {
 609                d->srp = val;
 610        }
 611        else if (regno == DCCR) {
 612                d->dccr = val;
 613        }
 614        else {
 615                /* Do not support registers in the current thread. */
 616                status = E07;
 617        }
 618        return status;
 619}
 620#endif
 621
 622/* Read a value from a specified register in the register image. Returns the
 623   value in the register or -1 for non-implemented registers.
 624   Should check consistency_status after a call which may be E05 after changes
 625   in the implementation. */
 626static int
 627read_register (char regno, unsigned int *valptr)
 628{
 629        registers *current_reg = &reg;
 630
 631        if (regno >= R0 && regno <= PC) {
 632                /* 32-bit register with simple offset. */
 633                *valptr = *(unsigned int *)((char *)current_reg + regno * sizeof(unsigned int));
 634                return SUCCESS;
 635        }
 636        else if (regno == P0 || regno == VR) {
 637                /* 8 bit register with complex offset. */
 638                *valptr = (unsigned int)(*(unsigned char *)
 639                                         ((char *)&(current_reg->p0) + (regno-P0) * sizeof(char)));
 640                return SUCCESS;
 641        }
 642        else if (regno == P4 || regno == CCR) {
 643                /* 16 bit register with complex offset. */
 644                *valptr = (unsigned int)(*(unsigned short *)
 645                                         ((char *)&(current_reg->p4) + (regno-P4) * sizeof(unsigned short)));
 646                return SUCCESS;
 647        }
 648        else if (regno >= MOF && regno <= USP) {
 649                /* 32 bit register with complex offset. */
 650                *valptr = *(unsigned int *)((char *)&(current_reg->p8)
 651                                            + (regno-P8) * sizeof(unsigned int));
 652                return SUCCESS;
 653        }
 654        else {
 655                /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
 656                consistency_status = E05;
 657                return E05;
 658        }
 659}
 660
 661/********************************** Packet I/O ******************************/
 662/* Returns the integer equivalent of a hexadecimal character. */
 663static int
 664hex (char ch)
 665{
 666        if ((ch >= 'a') && (ch <= 'f'))
 667                return (ch - 'a' + 10);
 668        if ((ch >= '0') && (ch <= '9'))
 669                return (ch - '0');
 670        if ((ch >= 'A') && (ch <= 'F'))
 671                return (ch - 'A' + 10);
 672        return (-1);
 673}
 674
 675/* Convert the memory, pointed to by mem into hexadecimal representation.
 676   Put the result in buf, and return a pointer to the last character
 677   in buf (null). */
 678
 679static int do_printk = 0;
 680
 681static char *
 682mem2hex(char *buf, unsigned char *mem, int count)
 683{
 684        int i;
 685        int ch;
 686        
 687        if (mem == NULL) {
 688                /* Bogus read from m0. FIXME: What constitutes a valid address? */
 689                for (i = 0; i < count; i++) {
 690                        *buf++ = '0';
 691                        *buf++ = '0';
 692                }
 693        } else {
 694                /* Valid mem address. */
 695                for (i = 0; i < count; i++) {
 696                        ch = *mem++;
 697                        buf = pack_hex_byte(buf, ch);
 698                }
 699        }
 700        
 701        /* Terminate properly. */
 702        *buf = '\0';
 703        return (buf);
 704}
 705
 706/* Convert the array, in hexadecimal representation, pointed to by buf into
 707   binary representation. Put the result in mem, and return a pointer to
 708   the character after the last byte written. */
 709static unsigned char*
 710hex2mem (unsigned char *mem, char *buf, int count)
 711{
 712        int i;
 713        unsigned char ch;
 714        for (i = 0; i < count; i++) {
 715                ch = hex (*buf++) << 4;
 716                ch = ch + hex (*buf++);
 717                *mem++ = ch;
 718        }
 719        return (mem);
 720}
 721
 722/* Put the content of the array, in binary representation, pointed to by buf
 723   into memory pointed to by mem, and return a pointer to the character after
 724   the last byte written.
 725   Gdb will escape $, #, and the escape char (0x7d). */
 726static unsigned char*
 727bin2mem (unsigned char *mem, unsigned char *buf, int count)
 728{
 729        int i;
 730        unsigned char *next;
 731        for (i = 0; i < count; i++) {
 732                /* Check for any escaped characters. Be paranoid and
 733                   only unescape chars that should be escaped. */
 734                if (*buf == 0x7d) {
 735                        next = buf + 1;
 736                        if (*next == 0x3 || *next == 0x4 || *next == 0x5D) /* #, $, ESC */
 737                                {
 738                                        buf++;
 739                                        *buf += 0x20;
 740                                }
 741                }
 742                *mem++ = *buf++;
 743        }
 744        return (mem);
 745}
 746
 747/* Await the sequence $<data>#<checksum> and store <data> in the array buffer
 748   returned. */
 749static void
 750getpacket (char *buffer)
 751{
 752        unsigned char checksum;
 753        unsigned char xmitcsum;
 754        int i;
 755        int count;
 756        char ch;
 757        do {
 758                while ((ch = getDebugChar ()) != '$')
 759                        /* Wait for the start character $ and ignore all other characters */;
 760                checksum = 0;
 761                xmitcsum = -1;
 762                count = 0;
 763                /* Read until a # or the end of the buffer is reached */
 764                while (count < BUFMAX) {
 765                        ch = getDebugChar ();
 766                        if (ch == '#')
 767                                break;
 768                        checksum = checksum + ch;
 769                        buffer[count] = ch;
 770                        count = count + 1;
 771                }
 772                buffer[count] = '\0';
 773                
 774                if (ch == '#') {
 775                        xmitcsum = hex (getDebugChar ()) << 4;
 776                        xmitcsum += hex (getDebugChar ());
 777                        if (checksum != xmitcsum) {
 778                                /* Wrong checksum */
 779                                putDebugChar ('-');
 780                        }
 781                        else {
 782                                /* Correct checksum */
 783                                putDebugChar ('+');
 784                                /* If sequence characters are received, reply with them */
 785                                if (buffer[2] == ':') {
 786                                        putDebugChar (buffer[0]);
 787                                        putDebugChar (buffer[1]);
 788                                        /* Remove the sequence characters from the buffer */
 789                                        count = gdb_cris_strlen (buffer);
 790                                        for (i = 3; i <= count; i++)
 791                                                buffer[i - 3] = buffer[i];
 792                                }
 793                        }
 794                }
 795        } while (checksum != xmitcsum);
 796}
 797
 798/* Send $<data>#<checksum> from the <data> in the array buffer. */
 799
 800static void
 801putpacket(char *buffer)
 802{
 803        int checksum;
 804        int runlen;
 805        int encode;
 806        
 807        do {
 808                char *src = buffer;
 809                putDebugChar ('$');
 810                checksum = 0;
 811                while (*src) {
 812                        /* Do run length encoding */
 813                        putDebugChar (*src);
 814                        checksum += *src;
 815                        runlen = 0;
 816                        while (runlen < RUNLENMAX && *src == src[runlen]) {
 817                                runlen++;
 818                        }
 819                        if (runlen > 3) {
 820                                /* Got a useful amount */
 821                                putDebugChar ('*');
 822                                checksum += '*';
 823                                encode = runlen + ' ' - 4;
 824                                putDebugChar (encode);
 825                                checksum += encode;
 826                                src += runlen;
 827                        }
 828                        else {
 829                                src++;
 830                        }
 831                }
 832                putDebugChar('#');
 833                putDebugChar(hex_asc_hi(checksum));
 834                putDebugChar(hex_asc_lo(checksum));
 835        } while(kgdb_started && (getDebugChar() != '+'));
 836}
 837
 838/* The string str is prepended with the GDB printout token and sent. Required
 839   in traditional implementations. */
 840void
 841putDebugString (const unsigned char *str, int length)
 842{
 843        remcomOutBuffer[0] = 'O';
 844        mem2hex(&remcomOutBuffer[1], (unsigned char *)str, length);
 845        putpacket(remcomOutBuffer);
 846}
 847
 848/********************************** Handle exceptions ************************/
 849/* Build and send a response packet in order to inform the host the
 850   stub is stopped. TAAn...:r...;n...:r...;n...:r...;
 851                    AA = signal number
 852                    n... = register number (hex)
 853                    r... = register contents
 854                    n... = `thread'
 855                    r... = thread process ID.  This is a hex integer.
 856                    n... = other string not starting with valid hex digit.
 857                    gdb should ignore this n,r pair and go on to the next.
 858                    This way we can extend the protocol. */
 859static void
 860stub_is_stopped(int sigval)
 861{
 862        char *ptr = remcomOutBuffer;
 863        int regno;
 864
 865        unsigned int reg_cont;
 866        int status;
 867        
 868        /* Send trap type (converted to signal) */
 869
 870        *ptr++ = 'T';
 871        ptr = pack_hex_byte(ptr, sigval);
 872
 873        /* Send register contents. We probably only need to send the
 874         * PC, frame pointer and stack pointer here. Other registers will be
 875         * explicitly asked for. But for now, send all.
 876         */
 877        
 878        for (regno = R0; regno <= USP; regno++) {
 879                /* Store n...:r...; for the registers in the buffer. */
 880
 881                status = read_register (regno, &reg_cont);
 882                
 883                if (status == SUCCESS) {
 884                        ptr = pack_hex_byte(ptr, regno);
 885                        *ptr++ = ':';
 886
 887                        ptr = mem2hex(ptr, (unsigned char *)&reg_cont,
 888                                      register_size[regno]);
 889                        *ptr++ = ';';
 890                }
 891                
 892        }
 893
 894#ifdef PROCESS_SUPPORT
 895        /* Store the registers of the executing thread. Assume that both step,
 896           continue, and register content requests are with respect to this
 897           thread. The executing task is from the operating system scheduler. */
 898
 899        current_thread_c = executing_task;
 900        current_thread_g = executing_task;
 901
 902        /* A struct assignment translates into a libc memcpy call. Avoid
 903           all libc functions in order to prevent recursive break points. */
 904        copy_registers (&reg_g, &reg, sizeof(registers));
 905
 906        /* Store thread:r...; with the executing task TID. */
 907        gdb_cris_strcpy (&remcomOutBuffer[pos], "thread:");
 908        pos += gdb_cris_strlen ("thread:");
 909        remcomOutBuffer[pos++] = hex_asc_hi(executing_task);
 910        remcomOutBuffer[pos++] = hex_asc_lo(executing_task);
 911        gdb_cris_strcpy (&remcomOutBuffer[pos], ";");
 912#endif
 913
 914        /* null-terminate and send it off */
 915
 916        *ptr = 0;
 917
 918        putpacket (remcomOutBuffer);
 919}
 920
 921/* All expected commands are sent from remote.c. Send a response according
 922   to the description in remote.c. */
 923static void
 924handle_exception (int sigval)
 925{
 926        /* Avoid warning of not used. */
 927
 928        USEDFUN(handle_exception);
 929        USEDVAR(internal_stack[0]);
 930
 931        /* Send response. */
 932
 933        stub_is_stopped (sigval);
 934
 935        for (;;) {
 936                remcomOutBuffer[0] = '\0';
 937                getpacket (remcomInBuffer);
 938                switch (remcomInBuffer[0]) {
 939                        case 'g':
 940                                /* Read registers: g
 941                                   Success: Each byte of register data is described by two hex digits.
 942                                   Registers are in the internal order for GDB, and the bytes
 943                                   in a register  are in the same order the machine uses.
 944                                   Failure: void. */
 945                                
 946                                {
 947#ifdef PROCESS_SUPPORT
 948                                        /* Use the special register content in the executing thread. */
 949                                        copy_registers (&reg_g, &reg, sizeof(registers));
 950                                        /* Replace the content available on the stack. */
 951                                        if (current_thread_g != executing_task) {
 952                                                copy_registers_from_stack (current_thread_g, &reg_g);
 953                                        }
 954                                        mem2hex ((unsigned char *)remcomOutBuffer, (unsigned char *)&reg_g, sizeof(registers));
 955#else
 956                                        mem2hex(remcomOutBuffer, (char *)&reg, sizeof(registers));
 957#endif
 958                                }
 959                                break;
 960                                
 961                        case 'G':
 962                                /* Write registers. GXX..XX
 963                                   Each byte of register data  is described by two hex digits.
 964                                   Success: OK
 965                                   Failure: void. */
 966#ifdef PROCESS_SUPPORT
 967                                hex2mem ((unsigned char *)&reg_g, &remcomInBuffer[1], sizeof(registers));
 968                                if (current_thread_g == executing_task) {
 969                                        copy_registers (&reg, &reg_g, sizeof(registers));
 970                                }
 971                                else {
 972                                        copy_registers_to_stack(current_thread_g, &reg_g);
 973                                }
 974#else
 975                                hex2mem((char *)&reg, &remcomInBuffer[1], sizeof(registers));
 976#endif
 977                                gdb_cris_strcpy (remcomOutBuffer, "OK");
 978                                break;
 979                                
 980                        case 'P':
 981                                /* Write register. Pn...=r...
 982                                   Write register n..., hex value without 0x, with value r...,
 983                                   which contains a hex value without 0x and two hex digits
 984                                   for each byte in the register (target byte order). P1f=11223344 means
 985                                   set register 31 to 44332211.
 986                                   Success: OK
 987                                   Failure: E02, E05 */
 988                                {
 989                                        char *suffix;
 990                                        int regno = gdb_cris_strtol (&remcomInBuffer[1], &suffix, 16);
 991                                        int status;
 992#ifdef PROCESS_SUPPORT
 993                                        if (current_thread_g != executing_task)
 994                                                status = write_stack_register (current_thread_g, regno, suffix+1);
 995                                        else
 996#endif
 997                                                status = write_register (regno, suffix+1);
 998
 999                                        switch (status) {
1000                                                case E02:
1001                                                        /* Do not support read-only registers. */
1002                                                        gdb_cris_strcpy (remcomOutBuffer, error_message[E02]);
1003                                                        break;
1004                                                case E05:
1005                                                        /* Do not support non-existing registers. */
1006                                                        gdb_cris_strcpy (remcomOutBuffer, error_message[E05]);
1007                                                        break;
1008                                                case E07:
1009                                                        /* Do not support non-existing registers on the stack. */
1010                                                        gdb_cris_strcpy (remcomOutBuffer, error_message[E07]);
1011                                                        break;
1012                                                default:
1013                                                        /* Valid register number. */
1014                                                        gdb_cris_strcpy (remcomOutBuffer, "OK");
1015                                                        break;
1016                                        }
1017                                }
1018                                break;
1019                                
1020                        case 'm':
1021                                /* Read from memory. mAA..AA,LLLL
1022                                   AA..AA is the address and LLLL is the length.
1023                                   Success: XX..XX is the memory content.  Can be fewer bytes than
1024                                   requested if only part of the data may be read. m6000120a,6c means
1025                                   retrieve 108 byte from base address 6000120a.
1026                                   Failure: void. */
1027                                {
1028                                        char *suffix;
1029                                        unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
1030                                                                                               &suffix, 16);                                        int length = gdb_cris_strtol(suffix+1, 0, 16);
1031                                        
1032                                        mem2hex(remcomOutBuffer, addr, length);
1033                                }
1034                                break;
1035                                
1036                        case 'X':
1037                                /* Write to memory. XAA..AA,LLLL:XX..XX
1038                                   AA..AA is the start address,  LLLL is the number of bytes, and
1039                                   XX..XX is the binary data.
1040                                   Success: OK
1041                                   Failure: void. */
1042                        case 'M':
1043                                /* Write to memory. MAA..AA,LLLL:XX..XX
1044                                   AA..AA is the start address,  LLLL is the number of bytes, and
1045                                   XX..XX is the hexadecimal data.
1046                                   Success: OK
1047                                   Failure: void. */
1048                                {
1049                                        char *lenptr;
1050                                        char *dataptr;
1051                                        unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
1052                                                                                      &lenptr, 16);
1053                                        int length = gdb_cris_strtol(lenptr+1, &dataptr, 16);
1054                                        if (*lenptr == ',' && *dataptr == ':') {
1055                                                if (remcomInBuffer[0] == 'M') {
1056                                                        hex2mem(addr, dataptr + 1, length);
1057                                                }
1058                                                else /* X */ {
1059                                                        bin2mem(addr, dataptr + 1, length);
1060                                                }
1061                                                gdb_cris_strcpy (remcomOutBuffer, "OK");
1062                                        }
1063                                        else {
1064                                                gdb_cris_strcpy (remcomOutBuffer, error_message[E06]);
1065                                        }
1066                                }
1067                                break;
1068                                
1069                        case 'c':
1070                                /* Continue execution. cAA..AA
1071                                   AA..AA is the address where execution is resumed. If AA..AA is
1072                                   omitted, resume at the present address.
1073                                   Success: return to the executing thread.
1074                                   Failure: will never know. */
1075                                if (remcomInBuffer[1] != '\0') {
1076                                        reg.pc = gdb_cris_strtol (&remcomInBuffer[1], 0, 16);
1077                                }
1078                                enableDebugIRQ();
1079                                return;
1080                                
1081                        case 's':
1082                                /* Step. sAA..AA
1083                                   AA..AA is the address where execution is resumed. If AA..AA is
1084                                   omitted, resume at the present address. Success: return to the
1085                                   executing thread. Failure: will never know.
1086                                   
1087                                   Should never be invoked. The single-step is implemented on
1088                                   the host side. If ever invoked, it is an internal error E04. */
1089                                gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
1090                                putpacket (remcomOutBuffer);
1091                                return;
1092                                
1093                        case '?':
1094                                /* The last signal which caused a stop. ?
1095                                   Success: SAA, where AA is the signal number.
1096                                   Failure: void. */
1097                                remcomOutBuffer[0] = 'S';
1098                                remcomOutBuffer[1] = hex_asc_hi(sigval);
1099                                remcomOutBuffer[2] = hex_asc_lo(sigval);
1100                                remcomOutBuffer[3] = 0;
1101                                break;
1102                                
1103                        case 'D':
1104                                /* Detach from host. D
1105                                   Success: OK, and return to the executing thread.
1106                                   Failure: will never know */
1107                                putpacket ("OK");
1108                                return;
1109                                
1110                        case 'k':
1111                        case 'r':
1112                                /* kill request or reset request.
1113                                   Success: restart of target.
1114                                   Failure: will never know. */
1115                                kill_restart ();
1116                                break;
1117                                
1118                        case 'C':
1119                        case 'S':
1120                        case '!':
1121                        case 'R':
1122                        case 'd':
1123                                /* Continue with signal sig. Csig;AA..AA
1124                                   Step with signal sig. Ssig;AA..AA
1125                                   Use the extended remote protocol. !
1126                                   Restart the target system. R0
1127                                   Toggle debug flag. d
1128                                   Search backwards. tAA:PP,MM
1129                                   Not supported: E04 */
1130                                gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
1131                                break;
1132#ifdef PROCESS_SUPPORT
1133
1134                        case 'T':
1135                                /* Thread alive. TXX
1136                                   Is thread XX alive?
1137                                   Success: OK, thread XX is alive.
1138                                   Failure: E03, thread XX is dead. */
1139                                {
1140                                        int thread_id = (int)gdb_cris_strtol (&remcomInBuffer[1], 0, 16);
1141                                        /* Cannot tell whether it is alive or not. */
1142                                        if (thread_id >= 0 && thread_id < number_of_tasks)
1143                                                gdb_cris_strcpy (remcomOutBuffer, "OK");
1144                                }
1145                                break;
1146                                                                
1147                        case 'H':
1148                                /* Set thread for subsequent operations: Hct
1149                                   c = 'c' for thread used in step and continue;
1150                                   t can be -1 for all threads.
1151                                   c = 'g' for thread used in other  operations.
1152                                   t = 0 means pick any thread.
1153                                   Success: OK
1154                                   Failure: E01 */
1155                                {
1156                                        int thread_id = gdb_cris_strtol (&remcomInBuffer[2], 0, 16);
1157                                        if (remcomInBuffer[1] == 'c') {
1158                                                /* c = 'c' for thread used in step and continue */
1159                                                /* Do not change current_thread_c here. It would create a mess in
1160                                                   the scheduler. */
1161                                                gdb_cris_strcpy (remcomOutBuffer, "OK");
1162                                        }
1163                                        else if (remcomInBuffer[1] == 'g') {
1164                                                /* c = 'g' for thread used in other  operations.
1165                                                   t = 0 means pick any thread. Impossible since the scheduler does
1166                                                   not allow that. */
1167                                                if (thread_id >= 0 && thread_id < number_of_tasks) {
1168                                                        current_thread_g = thread_id;
1169                                                        gdb_cris_strcpy (remcomOutBuffer, "OK");
1170                                                }
1171                                                else {
1172                                                        /* Not expected - send an error message. */
1173                                                        gdb_cris_strcpy (remcomOutBuffer, error_message[E01]);
1174                                                }
1175                                        }
1176                                        else {
1177                                                /* Not expected - send an error message. */
1178                                                gdb_cris_strcpy (remcomOutBuffer, error_message[E01]);
1179                                        }
1180                                }
1181                                break;
1182                                
1183                        case 'q':
1184                        case 'Q':
1185                                /* Query of general interest. qXXXX
1186                                   Set general value XXXX. QXXXX=yyyy */
1187                                {
1188                                        int pos;
1189                                        int nextpos;
1190                                        int thread_id;
1191                                        
1192                                        switch (remcomInBuffer[1]) {
1193                                                case 'C':
1194                                                        /* Identify the remote current thread. */
1195                                                        gdb_cris_strcpy (&remcomOutBuffer[0], "QC");
1196                                                        remcomOutBuffer[2] = hex_asc_hi(current_thread_c);
1197                                                        remcomOutBuffer[3] = hex_asc_lo(current_thread_c);
1198                                                        remcomOutBuffer[4] = '\0';
1199                                                        break;
1200                                                case 'L':
1201                                                        gdb_cris_strcpy (&remcomOutBuffer[0], "QM");
1202                                                        /* Reply with number of threads. */
1203                                                        if (os_is_started()) {
1204                                                                remcomOutBuffer[2] = hex_asc_hi(number_of_tasks);
1205                                                                remcomOutBuffer[3] = hex_asc_lo(number_of_tasks);
1206                                                        }
1207                                                        else {
1208                                                                remcomOutBuffer[2] = hex_asc_hi(0);
1209                                                                remcomOutBuffer[3] = hex_asc_lo(1);
1210                                                        }
1211                                                        /* Done with the reply. */
1212                                                        remcomOutBuffer[4] = hex_asc_lo(1);
1213                                                        pos = 5;
1214                                                        /* Expects the argument thread id. */
1215                                                        for (; pos < (5 + HEXCHARS_IN_THREAD_ID); pos++)
1216                                                                remcomOutBuffer[pos] = remcomInBuffer[pos];
1217                                                        /* Reply with the thread identifiers. */
1218                                                        if (os_is_started()) {
1219                                                                /* Store the thread identifiers of all tasks. */
1220                                                                for (thread_id = 0; thread_id < number_of_tasks; thread_id++) {
1221                                                                        nextpos = pos + HEXCHARS_IN_THREAD_ID - 1;
1222                                                                        for (; pos < nextpos; pos ++)
1223                                                                                remcomOutBuffer[pos] = hex_asc_lo(0);
1224                                                                        remcomOutBuffer[pos++] = hex_asc_lo(thread_id);
1225                                                                }
1226                                                        }
1227                                                        else {
1228                                                                /* Store the thread identifier of the boot task. */
1229                                                                nextpos = pos + HEXCHARS_IN_THREAD_ID - 1;
1230                                                                for (; pos < nextpos; pos ++)
1231                                                                        remcomOutBuffer[pos] = hex_asc_lo(0);
1232                                                                remcomOutBuffer[pos++] = hex_asc_lo(current_thread_c);
1233                                                        }
1234                                                        remcomOutBuffer[pos] = '\0';
1235                                                        break;
1236                                                default:
1237                                                        /* Not supported: "" */
1238                                                        /* Request information about section offsets: qOffsets. */
1239                                                        remcomOutBuffer[0] = 0;
1240                                                        break;
1241                                        }
1242                                }
1243                                break;
1244#endif /* PROCESS_SUPPORT */
1245                                
1246                        default:
1247                                /* The stub should ignore other request and send an empty
1248                                   response ($#<checksum>). This way we can extend the protocol and GDB
1249                                   can tell whether the stub it is talking to uses the old or the new. */
1250                                remcomOutBuffer[0] = 0;
1251                                break;
1252                }
1253                putpacket(remcomOutBuffer);
1254        }
1255}
1256
1257/* Performs a complete re-start from scratch. */
1258static void
1259kill_restart ()
1260{
1261        machine_restart("");
1262}
1263
1264/********************************** Breakpoint *******************************/
1265/* The hook for both a static (compiled) and a dynamic breakpoint set by GDB.
1266   An internal stack is used by the stub. The register image of the caller is
1267   stored in the structure register_image.
1268   Interactive communication with the host is handled by handle_exception and
1269   finally the register image is restored. */
1270
1271void kgdb_handle_breakpoint(void);
1272
1273asm ("
1274  .global kgdb_handle_breakpoint
1275kgdb_handle_breakpoint:
1276;;
1277;; Response to the break-instruction
1278;;
1279;; Create a register image of the caller
1280;;
1281  move     $dccr,[reg+0x5E] ; Save the flags in DCCR before disable interrupts
1282  di                        ; Disable interrupts
1283  move.d   $r0,[reg]        ; Save R0
1284  move.d   $r1,[reg+0x04]   ; Save R1
1285  move.d   $r2,[reg+0x08]   ; Save R2
1286  move.d   $r3,[reg+0x0C]   ; Save R3
1287  move.d   $r4,[reg+0x10]   ; Save R4
1288  move.d   $r5,[reg+0x14]   ; Save R5
1289  move.d   $r6,[reg+0x18]   ; Save R6
1290  move.d   $r7,[reg+0x1C]   ; Save R7
1291  move.d   $r8,[reg+0x20]   ; Save R8
1292  move.d   $r9,[reg+0x24]   ; Save R9
1293  move.d   $r10,[reg+0x28]  ; Save R10
1294  move.d   $r11,[reg+0x2C]  ; Save R11
1295  move.d   $r12,[reg+0x30]  ; Save R12
1296  move.d   $r13,[reg+0x34]  ; Save R13
1297  move.d   $sp,[reg+0x38]   ; Save SP (R14)
1298;; Due to the old assembler-versions BRP might not be recognized
1299  .word 0xE670              ; move brp,$r0
1300  subq     2,$r0             ; Set to address of previous instruction.
1301  move.d   $r0,[reg+0x3c]   ; Save the address in PC (R15)
1302  clear.b  [reg+0x40]      ; Clear P0
1303  move     $vr,[reg+0x41]   ; Save special register P1
1304  clear.w  [reg+0x42]      ; Clear P4
1305  move     $ccr,[reg+0x44]  ; Save special register CCR
1306  move     $mof,[reg+0x46]  ; P7
1307  clear.d  [reg+0x4A]      ; Clear P8
1308  move     $ibr,[reg+0x4E]  ; P9,
1309  move     $irp,[reg+0x52]  ; P10,
1310  move     $srp,[reg+0x56]  ; P11,
1311  move     $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR
1312                            ; P13, register DCCR already saved
1313;; Due to the old assembler-versions BRP might not be recognized
1314  .word 0xE670              ; move brp,r0
1315;; Static (compiled) breakpoints must return to the next instruction in order
1316;; to avoid infinite loops. Dynamic (gdb-invoked) must restore the instruction
1317;; in order to execute it when execution is continued.
1318  test.b   [is_dyn_brkp]    ; Is this a dynamic breakpoint?
1319  beq      is_static         ; No, a static breakpoint
1320  nop
1321  subq     2,$r0              ; rerun the instruction the break replaced
1322is_static:
1323  moveq    1,$r1
1324  move.b   $r1,[is_dyn_brkp] ; Set the state variable to dynamic breakpoint
1325  move.d   $r0,[reg+0x62]    ; Save the return address in BRP
1326  move     $usp,[reg+0x66]   ; USP
1327;;
1328;; Handle the communication
1329;;
1330  move.d   internal_stack+1020,$sp ; Use the internal stack which grows upward
1331  moveq    5,$r10                   ; SIGTRAP
1332  jsr      handle_exception       ; Interactive routine
1333;;
1334;; Return to the caller
1335;;
1336   move.d  [reg],$r0         ; Restore R0
1337   move.d  [reg+0x04],$r1    ; Restore R1
1338   move.d  [reg+0x08],$r2    ; Restore R2
1339   move.d  [reg+0x0C],$r3    ; Restore R3
1340   move.d  [reg+0x10],$r4    ; Restore R4
1341   move.d  [reg+0x14],$r5    ; Restore R5
1342   move.d  [reg+0x18],$r6    ; Restore R6
1343   move.d  [reg+0x1C],$r7    ; Restore R7
1344   move.d  [reg+0x20],$r8    ; Restore R8
1345   move.d  [reg+0x24],$r9    ; Restore R9
1346   move.d  [reg+0x28],$r10   ; Restore R10
1347   move.d  [reg+0x2C],$r11   ; Restore R11
1348   move.d  [reg+0x30],$r12   ; Restore R12
1349   move.d  [reg+0x34],$r13   ; Restore R13
1350;;
1351;; FIXME: Which registers should be restored?
1352;;
1353   move.d  [reg+0x38],$sp    ; Restore SP (R14)
1354   move    [reg+0x56],$srp   ; Restore the subroutine return pointer.
1355   move    [reg+0x5E],$dccr  ; Restore DCCR
1356   move    [reg+0x66],$usp   ; Restore USP
1357   jump    [reg+0x62]       ; A jump to the content in register BRP works.
1358   nop                       ;
1359");
1360
1361/* The hook for an interrupt generated by GDB. An internal stack is used
1362   by the stub. The register image of the caller is stored in the structure
1363   register_image. Interactive communication with the host is handled by
1364   handle_exception and finally the register image is restored. Due to the
1365   old assembler which does not recognise the break instruction and the
1366   breakpoint return pointer hex-code is used. */
1367
1368void kgdb_handle_serial(void);
1369
1370asm ("
1371  .global kgdb_handle_serial
1372kgdb_handle_serial:
1373;;
1374;; Response to a serial interrupt
1375;;
1376
1377  move     $dccr,[reg+0x5E] ; Save the flags in DCCR
1378  di                        ; Disable interrupts
1379  move.d   $r0,[reg]        ; Save R0
1380  move.d   $r1,[reg+0x04]   ; Save R1
1381  move.d   $r2,[reg+0x08]   ; Save R2
1382  move.d   $r3,[reg+0x0C]   ; Save R3
1383  move.d   $r4,[reg+0x10]   ; Save R4
1384  move.d   $r5,[reg+0x14]   ; Save R5
1385  move.d   $r6,[reg+0x18]   ; Save R6
1386  move.d   $r7,[reg+0x1C]   ; Save R7
1387  move.d   $r8,[reg+0x20]   ; Save R8
1388  move.d   $r9,[reg+0x24]   ; Save R9
1389  move.d   $r10,[reg+0x28]  ; Save R10
1390  move.d   $r11,[reg+0x2C]  ; Save R11
1391  move.d   $r12,[reg+0x30]  ; Save R12
1392  move.d   $r13,[reg+0x34]  ; Save R13
1393  move.d   $sp,[reg+0x38]   ; Save SP (R14)
1394  move     $irp,[reg+0x3c]  ; Save the address in PC (R15)
1395  clear.b  [reg+0x40]      ; Clear P0
1396  move     $vr,[reg+0x41]   ; Save special register P1,
1397  clear.w  [reg+0x42]      ; Clear P4
1398  move     $ccr,[reg+0x44]  ; Save special register CCR
1399  move     $mof,[reg+0x46]  ; P7
1400  clear.d  [reg+0x4A]      ; Clear P8
1401  move     $ibr,[reg+0x4E]  ; P9,
1402  move     $irp,[reg+0x52]  ; P10,
1403  move     $srp,[reg+0x56]  ; P11,
1404  move     $dtp0,[reg+0x5A] ; P12, register BAR, assembler might not know BAR
1405                            ; P13, register DCCR already saved
1406;; Due to the old assembler-versions BRP might not be recognized
1407  .word 0xE670              ; move brp,r0
1408  move.d   $r0,[reg+0x62]   ; Save the return address in BRP
1409  move     $usp,[reg+0x66]  ; USP
1410
1411;; get the serial character (from debugport.c) and check if it is a ctrl-c
1412
1413  jsr getDebugChar
1414  cmp.b 3, $r10
1415  bne goback
1416  nop
1417
1418  move.d  [reg+0x5E], $r10              ; Get DCCR
1419  btstq    8, $r10                      ; Test the U-flag.
1420  bmi      goback
1421  nop
1422
1423;;
1424;; Handle the communication
1425;;
1426  move.d   internal_stack+1020,$sp ; Use the internal stack
1427  moveq    2,$r10                   ; SIGINT
1428  jsr      handle_exception       ; Interactive routine
1429
1430goback:
1431;;
1432;; Return to the caller
1433;;
1434   move.d  [reg],$r0         ; Restore R0
1435   move.d  [reg+0x04],$r1    ; Restore R1
1436   move.d  [reg+0x08],$r2    ; Restore R2
1437   move.d  [reg+0x0C],$r3    ; Restore R3
1438   move.d  [reg+0x10],$r4    ; Restore R4
1439   move.d  [reg+0x14],$r5    ; Restore R5
1440   move.d  [reg+0x18],$r6    ; Restore R6
1441   move.d  [reg+0x1C],$r7    ; Restore R7
1442   move.d  [reg+0x20],$r8    ; Restore R8
1443   move.d  [reg+0x24],$r9    ; Restore R9
1444   move.d  [reg+0x28],$r10   ; Restore R10
1445   move.d  [reg+0x2C],$r11   ; Restore R11
1446   move.d  [reg+0x30],$r12   ; Restore R12
1447   move.d  [reg+0x34],$r13   ; Restore R13
1448;;
1449;; FIXME: Which registers should be restored?
1450;;
1451   move.d  [reg+0x38],$sp    ; Restore SP (R14)
1452   move    [reg+0x56],$srp   ; Restore the subroutine return pointer.
1453   move    [reg+0x5E],$dccr  ; Restore DCCR
1454   move    [reg+0x66],$usp   ; Restore USP
1455   reti                      ; Return from the interrupt routine
1456   nop
1457");
1458
1459/* Use this static breakpoint in the start-up only. */
1460
1461void
1462breakpoint(void)
1463{
1464        kgdb_started = 1;
1465        is_dyn_brkp = 0;     /* This is a static, not a dynamic breakpoint. */
1466        __asm__ volatile ("break 8"); /* Jump to handle_breakpoint. */
1467}
1468
1469/* initialize kgdb. doesn't break into the debugger, but sets up irq and ports */
1470
1471void
1472kgdb_init(void)
1473{
1474        /* could initialize debug port as well but it's done in head.S already... */
1475
1476        /* breakpoint handler is now set in irq.c */
1477        set_int_vector(8, kgdb_handle_serial);
1478        
1479        enableDebugIRQ();
1480}
1481
1482/****************************** End of file **********************************/
1483
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.