source: trunk/libs/newlib/src/libgloss/debug.c @ 607

/*
 * 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>

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

/*
 * indicate to caller of mem2hex or hex2mem that there has been an error. 
 * 0 means ok, 1 means error
 */
volatile int mem_err = 0;

/*
 * 1 means print debugging messages from the target, 0 means be quiet. This is
 * changed by gdb_debug().
 */
int remote_debug = 0;

/*
 * indicate whether the debug vectors ahave been initialized
 * 0 means not yet, 1 means yep, it's ready.
 */
int initialized = 0;

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

/* this is a list of signal to exception mappings. */
extern struct trap_info hard_trap_info[];

/* this is a memory fault exception handler, used by mem2hex & hex2mem */
extern void set_mem_fault_trap();

/*
 * print debugging messages. This uses print, rather than one of the
 * stdio routines, cause if there are stack or memory problems, the
 * stdio routines don't work.
 *      params are the debug level, and the string to print
 *      it doesn't return anything.
 */
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");
}

/*
 * convert an ascii hex digit to a number.
 *      param is hex digit.
 *      returns a decimal digit.
 */
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;
}

/*
 * convert number NIB to a hex digit.
 *      param is a decimal digit.
 *      returns a hex digit.
 */
char
digit2hex(int digit)
{
  if (digit < 10)
    return '0' + digit;
  else
    return 'a' + digit - 10;
}

/* 
 * Convert the memory pointed to by mem into hex, placing result in buf.
 * Return a pointer to the last char put in buf (null), in case of mem fault,
 * return 0.
 * If MAY_FAULT is non-zero, then we will handle memory faults by returning
 * a 0, else treat a fault like any other fault in the stub.
 */
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;
}

/*
 * Convert the hex array pointed to by buf into binary to be placed in mem
 * return a pointer to the character AFTER the last byte written
 */
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;
}

/*
 * while we find nice hex chars, build an int.
 *      param is a pointer to the string.
 *      returns the int in the param field, and the number of chars processed.
 */
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);
}

/*
 * Scan for the sequence $<data>#<checksum>
 */
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 = (inbyte() & 0x7f)) != '$') ;
    
    checksum = 0;
    xmitcsum = -1;
    
    count = 0;
    
    /* now, read until a # or end of buffer is found */
    while (count < BUFMAX) {
      ch = 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(inbyte() & 0x7f) << 4;
      xmitcsum |= hex2digit(inbyte() & 0x7f);
#if 1
      /* Humans shouldn't have to figure out checksums to type to it. */
      outbyte ('+');
      return;
#endif
      if (checksum != xmitcsum)
        outbyte('-');   /* failed checksum */
      else {
        outbyte('+'); /* successful transfer */
        /* if a sequence char is present, reply the sequence ID */
        if (buffer[2] == ':') {
          outbyte(buffer[0]);
          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);
}

/*
 * Send the packet in buffer.
 */
void
putpacket(unsigned char *buffer)
{
  unsigned char checksum;
  int count;
  unsigned char ch;

  /*  $<packet info>#<checksum>. */
  do {
    outbyte('$');
    checksum = 0;
    count = 0;
    
    while (ch = buffer[count]) {
      if (! outbyte(ch))
        return;
      checksum += ch;
      count += 1;
    }
    
    outbyte('#');
    outbyte(digit2hex(checksum >> 4));
    outbyte(digit2hex(checksum & 0xf));
    
  }
  while ((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()");
}

/* Convert the hardware trap type code to a unix signal number. */

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 */
}

/*
 * Set up exception handlers for tracing and breakpoints
 */
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.  */

  outbyte ('+');
  initialized = 1;

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

/*
 * make a return packet.
 *      param is the value to return.
 *              0 = OK, any other value is converted to a two digit hex number.
 *      returns a string or "OK" or "ENN", where NN is the error number. Each N
 *              is an ASCII encoded hex digit.
 */
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);
}

/*
 * g - read registers.
 *      no params.
 *      returns a vector of words, size is NUM_REGS.
 */
char *
gdb_read_registers()
{
}

/*
 * G - write registers.
 *      param is a vector of words, size is NUM_REGS.
 *      returns an OK or an error number.
 */
char *
gdb_write_registers(char *regs)
{
}

/*
 * m - read memory.
 *      params are the address to start the read at and the number of
 *              bytes to read.  
 *      returns a vector of nbytes or an error number.
 *      Can be fewer bytes than requested if able to read only part of the
 *      data. 
 */
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));
  }
}

/*
 * M write memory
 *      params are the address to start writing to, the number of
 *              bytes to write, and the new values of the bytes.
 *      returns an OK or an error number.
 */
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));
  }
}

/*
 * c - continue at address.
 *      param is the address to start at, and an optional signal. If
 *              sig is zero, then ignore it.
 *      returns an OK or an error number.
 */
char *
gdb_continue(int sig, long addr)
{
}

/*
 * s - step instruction(s)
 *      param is the address to start at, and an optional signal. If
 *              sig is zero, then ignore it.
 *      returns an OK or an error number.
 */
char *
gdb_step(int sig, long addr)
{
}

/*
 * k - kill program.
 *      no params.
 *      returns an OK or an error number.
 */
char *
gdb_kill()
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * ? - last signal.
 *      no params.
 *      returns the last signal number.
 */
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);
}

/*
 * b - change baud rate.
 *      param is the new baudrate
 *      returns the baud rate.
 */
char *
gdb_baudrate(int baud)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * T - dump state.
 *      no params.
 *      returns the signal number, the registers, the thread ID, and
 *              possible extensions in a vector that looks like:
 *                      TAAn...:r...;n...:r...;n...:r...; where:
 *                       AA = signal number
 *                       n... = register number (hex)
 *                       r... = register contents
 *                       n... = `thread'
 *                       r... = thread process ID.  This is a hex integer.
 *                       n... = other string not starting with valid hex digit.
 *                              gdb should ignore this n,r pair and go on to
 *                              the next. This way we can extend the protocol.
 */
char *
gdb_dump_state()
{
}

/*
 * D - host requests a detach
 *      no params.
 *      returns either a S, T, W, or X command.
 *      returns an OK or an error number.
 */
char *
gdb_detach()
{
}

/*
 * H - set thread.
 *      params are the command to execute and the thread ID.
 *              cmd = 'c' for thread used in step and continue;
 *              cmd = 'g' for thread used in other operations.
 *              tid = -1 for all threads.
 *              tid = zero, pick a thread,any thread.
 *      returns an OK or an error number.
 */
char *
gdb_set_thread(int cmd, int tid)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * p - read one register.
 *      param is the register number.
 *      returns the register value or ENN.
 */
char *
gdb_read_reg(int reg)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * P - write one register.
 *      params are the register number, and it's new value.
 *      returns the register value or ENN.
 */
char *
gdb_write_reg(int reg, long val)
{
  /* generically, we can't do anything for this command */
  
  return(make_return_packet(OK));
}

/*
 * W - process exited.
 *      no params.
 *      returns the exit status.
 */
char *
gdb_exited()
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * X - process terminated.
 *      no params.
 *      returns the last signal.
 */
char *
gdb_terminated()
{
}

/*
 * O - hex encoding.
 *      params are a vector of bytes, and the number of bytes to encode.
 *      returns a vector of ASCII encoded hex numbers.
 */
char *
gdb_hex(char *str, int nbytes)
{
}

/*
 * A - tread alive request.
 *      param is the thread ID.
 *      returns an OK or an error number.
 */
char *
gdb_thread_alive(int tid)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * ! - extended protocol.
 *      no params.
 *      returns an OK or an error number.
 */
char *
gdb_extended()
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * d - toggle gdb stub diagnostics.
 *      no params.
 *      returns an OK or an error number.
 */
char *
gdb_debug()
{
  if (remote_debug > 0)
    remote_debug = 0;
  else
    remote_debug = 1;

  return(make_return_packet(OK));
}

/*
 * d - toggle gdb stub.
 *      no params.
 *      returns an OK or an error number.
 */
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));
}

/*
 * r - reset target
 *      no params.
 *      returns an OK or an error number.
 */
char *
gdb_reset()
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * t - search backwards.
 *      params are the address to start searching from, a pattern to match, and
 *              the mask to use.
 *      FIXME: not entirely sure what this is supposed to return.
 */
char *
gdb_search(long addr, long pat, long mask)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * q - general get query.
 *      param is a string, that's the query to be executed.
 *      FIXME: not entirely sure what this is supposed to return.
 */
char *
gdb_get_query(char *query)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}

/*
 * Q - general set query
 *      param is a string, that's the query to be executed.
 *      FIXME: not entirely sure what this means.
 *      returns an OK or an error number.
 */
char *
gdb_set(char *query)
{
  /* generically, we can't do anything for this command */
  return(make_return_packet(OK));
}