---

/projects/cubeos/src_current/libc/debug.c

Go to the documentation of this file.

/*  src_experimental/libc/debug.c
   CubeOS Version 0.4.90 experimental
   Copyright (C) 1999,2000 Holger Kenn

   CubeOS is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or any later version.

   CubeOS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

 */
/*
 * Copyright (c) 1995, 1996 Cygnus Support
 *
 * The authors hereby grant permission to use, copy, modify, distribute,
 * and license this software and its documentation for any purpose, provided
 * that existing copyright notices are retained in all copies and that this
 * notice is included verbatim in any distributions. No written agreement,
 * license, or royalty fee is required for any of the authorized uses.
 * Modifications to this software may be copyrighted by their authors
 * and need not follow the licensing terms described here, provided that
 * the new terms are clearly indicated on the first page of each file where
 * they apply.
 */

/*
 *   A debug packet whose contents are <data> looks like:
 *
 *        $ <data> # CSUM1 CSUM2
 *
 *        <data> must be ASCII alphanumeric and cannot include characters
 *        '$' or '#'.  If <data> starts with two characters followed by
 *        ':', then the existing stubs interpret this as a sequence number.
 *
 *       CSUM1 and CSUM2 are ascii hex representation of an 8-bit 
 *        checksum of <data>, the most significant nibble is sent first.
 *        the hex digits 0-9,a-f are used.
 *
 *   We respond with:
 *
 *        +       - if CSUM is correct and ready for next packet
 *        -       - if CSUM is incorrect
 *
 *   <data> is as follows:
 *   Most values are encoded in ascii hex digits.
 */

#include "debug.h"
#include <signal.h>
#include <kio.h>

/*
 * buffers that hold the packets while they're being constructed.
 */
char packet_in_buf[BUFMAX]; 
char packet_out_buf[BUFMAX]; 
int packet_index;       

volatile int mem_err = 0; 

int remote_debug = 0;

int initialized = 0;

/*
 * These variables are instantialted in the GDB stub code.
 */

extern struct trap_info hard_trap_info[];

extern void set_mem_fault_trap ();

void debuglog (int level, char *msg)
{
        char *p;
        unsigned char buf[BUFMAX];
        char newmsg[BUFMAX];
        int i;

        if (level > remote_debug)
                return;

        if ((level < 0) || (level > 100)) {
                print ("ERROR: debug print level out of range");
                return;
        }
        /* convert some characters so it'll look right in the log */
        p = newmsg;
        for (i = 0; msg[i] != '\0'; i++) {
                if (i > BUFMAX)
                        print ("\r\nERROR: Debug message too long\r\n");
                switch (msg[i]) {
                case '\n':      /* newlines */
                        *p++ = '\\';
                        *p++ = 'n';
                        continue;
                case '\r':      /* carriage returns */
                        *p++ = '\\';
                        *p++ = 'r';
                        continue;
                case '\033':    /* escape */
                        *p++ = '\\';
                        *p++ = 'e';
                        continue;
                case '\t':      /* tab */
                        *p++ = '\\';
                        *p++ = 't';
                        continue;
                case '\b':      /* backspace */
                        *p++ = '\\';
                        *p++ = 'b';
                        continue;
                default:        /* no change */
                        *p++ = msg[i];
                }

                if (msg[i] < 26) {      /* modify control characters */
                        *p++ = '^';
                        *p++ = msg[i] + 'A';
                        continue;
                }
                if (msg[i] >= 127) {    /* modify control characters */
                        *p++ = '!';
                        *p++ = msg[i] + 'A';
                        continue;
                }
        }
        *p = '\0';              /* terminate the string */
        print (newmsg);
        print ("\r\n");
}

int hex2digit (int digit)
{
        if (digit == 0)
                return 0;

        if (digit >= '0' && digit <= '9')
                return digit - '0';
        if (digit >= 'a' && digit <= 'f')
                return digit - 'a' + 10;
        if (digit >= 'A' && digit <= 'F')
                return digit - 'A' + 10;

        /* shouldn't ever get this far */
        return ERROR;
}

char digit2hex (int digit)
{
        if (digit < 10)
                return '0' + digit;
        else
                return 'a' + digit - 10;
}

unsigned char *
  mem2hex (unsigned char *mem, unsigned char *buf, int count, int may_fault)
{
        unsigned char ch;

        DEBUG (1, "In mem2hex");

        set_mem_fault_trap (MAY_FAULT);

        while (count-- > 0) {
                ch = *mem++;
                if (mem_err) {
                        DEBUG (1, "memory fault in mem2hex");
                        return 0;
                }
                *buf++ = digit2hex (ch >> 4);
                *buf++ = digit2hex (ch & 0xf);
        }

        *buf = 0;

        set_mem_fault_trap (OK);

        return buf;
}

unsigned char *
  hex2mem (unsigned char *buf, unsigned char *mem, int count, int may_fault)
{
        int i;
        unsigned char ch;

        DEBUG (1, "In hex2mem");

        set_mem_fault_trap (may_fault);

        for (i = 0; i < count; i++) {
                ch = hex2digit (*buf++) << 4;
                ch |= hex2digit (*buf++);
                *mem++ = ch;
                if (mem_err)
                        return 0;
        }

        set_mem_fault_trap (0);

        return mem;
}

int hex2int (char **ptr, int *intValue)
{
        int numChars = 0;
        int hexValue;

        *intValue = 0;

        while (**ptr) {
                hexValue = hex2digit (**ptr);
                if (hexValue < 0)
                        break;

                *intValue = (*intValue << 4) | hexValue;
                numChars++;
                (*ptr)++;
        }
        return (numChars);
}

void getpacket (unsigned char *buffer)
{
        unsigned char checksum;
        unsigned char xmitcsum;
        int i;
        int count;
        unsigned char ch;

        do {
                /* wait around for the start character, ignore all other characters */
                while ((ch = (_LIBC_inbyte () & 0x7f)) != '$');

                checksum = 0;
                xmitcsum = -1;

                count = 0;

                /* now, read until a # or end of buffer is found */
                while (count < BUFMAX) {
                        ch = _LIBC_inbyte () & 0x7f;
                        if (ch == '#')
                                break;
                        checksum = checksum + ch;
                        buffer[count] = ch;
                        count = count + 1;
                }

                if (count >= BUFMAX)
                        continue;

                buffer[count] = 0;

                if (ch == '#') {
                        xmitcsum = hex2digit (_LIBC_inbyte () & 0x7f) << 4;
                        xmitcsum |= hex2digit (_LIBC_inbyte () & 0x7f);
#if 1
                        /* Humans shouldn't have to figure out checksums to type to it. */
                        _LIBC_outbyte ('+');
                        return;
#endif
                        if (checksum != xmitcsum)
                                _LIBC_outbyte ('-');    /* failed checksum */
                        else {
                                _LIBC_outbyte ('+');    /* successful transfer */
                                /* if a sequence char is present, reply the sequence ID */
                                if (buffer[2] == ':') {
                                        _LIBC_outbyte (buffer[0]);
                                        _LIBC_outbyte (buffer[1]);
                                        /* remove sequence chars from buffer */
                                        count = strlen (buffer);
                                        for (i = 3; i <= count; i++)
                                                buffer[i - 3] = buffer[i];
                                }
                        }
                }
        }
        while (checksum != xmitcsum);
}

void putpacket (unsigned char *buffer)
{
        unsigned char checksum;
        int count;
        unsigned char ch;

        /* $<packet info>#<checksum>. */
        do {
                _LIBC_outbyte ('$');
                checksum = 0;
                count = 0;

                while (ch = buffer[count]) {
                        if (!_LIBC_outbyte (ch))
                                return;
                        checksum += ch;
                        count += 1;
                }

                _LIBC_outbyte ('#');
                _LIBC_outbyte (digit2hex (checksum >> 4));
                _LIBC_outbyte (digit2hex (checksum & 0xf));

        }
        while ((_LIBC_inbyte () & 0x7f) != '+');
}

void gdb_event_loop (int sigval, unsigned long *registers)
{
        int addr;
        int length;
        unsigned char *ptr;

        ptr = packet_out_buf;

        DEBUG (1, "In gdb_event_loop");

        while (1) {
                packet_out_buf[0] = 0;

                getpacket (packet_in_buf);
                ptr = &packet_in_buf[1];

                switch (packet_in_buf[0]) {
                case '?':       /* get the last known signal */
                        gdb_last_signal (sigval);
                        break;

                case 'd':       /* toggle debug messages from the stub */
                        gdb_toggle ();
                        break;

                case 'g':       /* return the value of the CPU registers */
                        target_read_registers (registers);
                        break;

                case 'G':       /* set the value of the CPU registers -
                                   return OK */
                        target_write_registers (registers);
                        break;

                case 'm':       /* mAA..AA,LLLL  Read LLLL bytes at address
                                   AA..AA */
                        /* Try to read %x,%x.  */
                        if (hex2int ((char **) &ptr, &addr)
                            && *ptr++ == ','
                            && hex2int ((char **) &ptr, &length)) {
                                gdb_read_memory (addr, length);
                        } else {
                                make_return_packet (1);
                        }
                        break;

                case 'M':       /* MAA..AA,LLLL: Write LLLL bytes at address
                                   AA.AA return OK */
                        /* Try to read '%x,%x:'.  */
                        if (hex2int ((char **) &ptr, &addr)
                            && *ptr++ == ','
                            && hex2int ((char **) &ptr, &length)
                            && *ptr++ == ':') {
                                gdb_write_memory (addr, length, ptr);
                        } else {
                                make_return_packet (2);
                        }
                        break;

                case 'c':       /* cAA..AA    Continue at address
                                   AA..AA(optional) */
                        /* try to read optional parameter, pc unchanged if no parm */
                        if (hex2int ((char **) &ptr, &addr)) {
                                write_pc (registers, addr);
                        }
                        /* 
                         * we need to flush the instruction cache here, as we may have
                         * deposited a breakpoint, and the icache probably has no way of
                         * knowing that a data ref to some location may have changed
                         * something that is in the instruction cache. 
                         */

                        flush_i_cache ();
                        /* by returning, we pick up execution where we left off */
                        return;

                        /* kill the program */
                case 'k':
                        gdb_kill ();
                        break;
                case 'r':       /* Reset */
                        target_reset ();
                        break;
                }               /* switch */

                /* reply to the request */
                putpacket (packet_out_buf);
        }
        DEBUG (1, "Leaving handle_exception()");
}

\ingroup GDBDEBUG
*/
int computeSignal (int tt)
{
        struct trap_info *ht;

        for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
                if (ht->tt == tt)
                        return ht->signo;

        return SIGHUP;          /* default for things we don't know about */
}

/*
\brief Set up exception handlers for tracing and breakpoints
\ingroup GDBDEBUG
*/
void set_debug_traps ()
{
        struct trap_info *ht;

        DEBUG (1, "Entering set_debug_traps()");

        if (hard_trap_info->tt == 0) {
                print ("ERROR: ARG#$@%^&*!! no hard trap info!!\r\n");
        }
        for (ht = hard_trap_info; ht->tt && ht->signo; ht++) {
                exception_handler (ht->tt, (unsigned long) default_trap_hook);
        }

        /* In case GDB is started before us, ack any packets (presumably "$?#xx") 

           sitting there.  */

        _LIBC_outbyte ('+');
        initialized = 1;

        DEBUG (1, "Leaving set_debug_traps()");
}

char *
  make_return_packet (int val)
{
        if (val == 0) {
                packet_out_buf[0] = 'O';
                packet_out_buf[1] = 'K';
                packet_out_buf[2] = 0;
        } else {
                packet_out_buf[0] = 'E';
                packet_out_buf[1] = digit2hex ((val >> 4) & 0xf);
                packet_out_buf[2] = digit2hex (val & 0xf);
                packet_out_buf[3] = 0;
        }
        return (packet_out_buf);
}

char *
  gdb_read_registers ()
{
}

char *
  gdb_write_registers (char *regs)
{
}

char *
  gdb_read_memory (long addr, int nbytes)
{
        if (mem2hex ((char *) addr, packet_out_buf, nbytes, MAY_FAULT))
                return (packet_out_buf);
        else {
                return (make_return_packet (3));
        }
}

char *
  gdb_write_memory (long addr, int nbytes, char *mem)
{
        if (hex2mem (mem, (char *) addr, nbytes, MAY_FAULT))
                return (make_return_packet (OK));
        else {
                return (make_return_packet (3));
        }
}

char *
  gdb_continue (int sig, long addr)
{
}

char *
  gdb_step (int sig, long addr)
{
}

char *
  gdb_kill ()
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_last_signal (int val)
{
        DEBUG (1, "Entering gdb_last_signal()");

        packet_out_buf[0] = 'S';
        packet_out_buf[1] = digit2hex (val >> 4);
        packet_out_buf[2] = digit2hex (val & 0xf);
        packet_out_buf[3] = 0;

        DEBUG (1, "Leaving gdb_last_signal()");
        return (packet_out_buf);
}

char *
  gdb_baudrate (int baud)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_dump_state ()
{
}

char *
  gdb_detach ()
{
}

char *
  gdb_set_thread (int cmd, int tid)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_read_reg (int reg)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_write_reg (int reg, long val)
{
        /* generically, we can't do anything for this command */

        return (make_return_packet (OK));
}

char *
  gdb_exited ()
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_terminated ()
{
}

char *
  gdb_hex (char *str, int nbytes)
{
}

char *
  gdb_thread_alive (int tid)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_extended ()
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_debug ()
{
        if (remote_debug > 0)
                remote_debug = 0;
        else
                remote_debug = 1;

        return (make_return_packet (OK));
}

char *
  gdb_toggle ()
{
        static int level = 0;

        if (remote_debug) {
                level = remote_debug;
                remote_debug = 0;
        } else {
                remote_debug = level;
        }

        return (make_return_packet (OK));
}

char *
  gdb_reset ()
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_search (long addr, long pat, long mask)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_get_query (char *query)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

char *
  gdb_set (char *query)
{
        /* generically, we can't do anything for this command */
        return (make_return_packet (OK));
}

---