ac_gdb.cpp

Go to the documentation of this file.

#include "ac_gdb.H"


AC_GDB::AC_GDB(AC_GDB_Interface* proc, int port) {
  this->connected  = 0;
  this->step       = 0;
  this->first_time = 1;
  this->proc       = proc;
  this->bps= new Breakpoints( BREAKPOINTS );
  this->set_port( port );
  this->disable();
}


AC_GDB::~AC_GDB() {
  delete bps;
  debug( "AC_GDB: connection closed!" );
}



/* Register Access ***********************************************************/

void AC_GDB::reg_read(char *ib, char *ob) {
  int i;
  ob[ 0 ] = '\0';
  char fmt[ 5 ] = "";

  /* 1 byte is represented in hexadecimal by 2 chars */
  snprintf( fmt, 5, "%%%02dx", sizeof( ac_word ) * 2 );

  for ( i = 0; i < proc->nRegs(); i ++ )
    sprintf( ob + strlen( ob ), fmt, proc->reg_read( i ) );
}


void AC_GDB::reg_write(char *ib, char *ob) {
  ac_word aux;
  int i, ss;
  char fmt[ 5 ] = "";

  ib ++; /* skip G */

  /* 1 byte is represented in hexadecimal by 2 chars */
  ss = sizeof( ac_word ) * 2;
  snprintf( fmt, 5, "%%%02dx", ss );

  for ( i = 0; i < 32; i ++) {
    sscanf( ib, fmt, &aux );
    proc->reg_write( i, aux );
    ib += ss;
  }

  strncpy( ob, "OK", GDB_BUFFERSIZE );
}



/* Memory Access *************************************************************/

void AC_GDB::mem_write( char *ib, char *ob ) {
  unsigned i, r;
  unsigned address, bytes;
  char *ib_h = ib;

  r = sscanf( ib, "M%x,%x:", &address, &bytes );

  ib = strchr( ib, ':' );

  if ( ( ! ib ) || ( r != 2 ) )
    /* Data is wrong! */
    strncpy( ob, "E01", GDB_BUFFERSIZE );
  else {
    int offset;
    ib ++; /* next char after ':' */

    /* be sure to not read outside in_buffer */
    offset = ib - ib_h;
    if ( ( ( bytes << 1 ) + 1 + offset ) >= GDB_BUFFERSIZE )
      /* [ offset | hex bytes repr...    | \0 ] <= GDB_BUFFERSIZE */
      bytes = ( ( GDB_BUFFERSIZE - offset ) >> 1 ) - 1;

    /* 1 byte is represented by 2 letters */
    bytes <<= 1;
    for ( i = 0; i < bytes; i += 2 )
      {
        if ( ib[ i ] == 0 )
          strncpy( ob, "E03", GDB_BUFFERSIZE); /* end of string ('\0'),
                                                  this is an error! */

        proc->mem_write( address,
                         ( hex( ib[ i ] ) << 4 ) + hex( ib[ i + 1 ] ) );
        address ++;
      }
    strncpy( ob, "OK", GDB_BUFFERSIZE );
  }
}


void AC_GDB::mem_read( char *ib, char *ob ) {
  unsigned i;
  unsigned char b;
  unsigned address = 0, bytes = 0;

  if ( sscanf( ib, "m%x,%x", &address, &bytes ) != 2 )
    /* Data is wrong! */
    strncpy( ob, "E01", GDB_BUFFERSIZE );
  else {
    /* be sure there is enough room for returning string + '\0' */
    if ( ( ( bytes << 1 ) + 1 ) >= GDB_BUFFERSIZE )
      /* Read just bytes that fit the buffer */
      bytes = ( GDB_BUFFERSIZE >> 1 ) - 1;

    for ( i = 0; i < bytes; i ++ )
      {
        b = proc->mem_read( address );

        /* represent the byte nibbles */
        ob[ i * 2 ] = hexchars[ b >> 4 ];
        ob[ i * 2 + 1 ] = hexchars[ b & 0xF ];

        address ++;
      }

    ob[ i * 2 ] = '\0';
  }
}





/* Execution Control *********************************************************/

void AC_GDB::continue_execution( char *ib, char *ob ) {
  unsigned address;

  if ( sscanf( ib, "c%x", &address ) == 1 )
    ac_resources::ac_pc = address;
  step = 0;
}


void AC_GDB::stepmode( char *ib, char *ob ) {
  unsigned address;
  if ( sscanf( ib, "s%x", &address ) == 1 )
    ac_resources::ac_pc = address;

  step = 1;
}


void AC_GDB::cc( char *ib, char *ob ) {
  snprintf( ob, GDB_BUFFERSIZE, "S%02x", SIGINT );
  step = 1;
}


void AC_GDB::exit(int ac_exit_status) {
  if ( disabled ) return;
  snprintf( out_buffer, GDB_BUFFERSIZE, "W%02x", ac_exit_status );
  comm_putpacket(out_buffer);
}


/* Break & Watch Point *******************************************************/

void AC_GDB::break_insert( char *ib, char *ob ) {
  int type, address, length;

  if ( sscanf( ib, "Z%x,%x,%x", &type, &address, &length ) != 3 )
    /* Data is wrong! */
    strncpy( ob, "E01", GDB_BUFFERSIZE );
  else {
    switch ( type ) {
    case 0:
      /* memory breakpoint */
      if ( bps->add( address ) == 0 )
        strncpy( ob, "OK", GDB_BUFFERSIZE );
      else
        strncpy( ob, "E00", GDB_BUFFERSIZE );
      break;

    case 1:
      /* hardware breakpoint */
      ob[ 0 ] = 0; /* FIXME --- not yet supported */
      break;

    case 2:
      /* write watchpoint */
      ob[ 0 ] = 0; /* FIXME --- not yet supported */
      break;

    case 3:
      /* read watchpoint */
      ob[ 0 ] = 0; /* FIXME --- not yet supported */
      break;

    case 4:
      /* access watchpoint */
      ob[ 0 ] = 0; /* FIXME --- not yet supported */
      break;
    }
  }
}


void AC_GDB::break_remove( char *ib, char *ob ) {
  int type, address, length;

  if ( sscanf( ib, "z%x,%x,%x", &type, &address, &length ) != 3 )
    /* Data is wrong! */
    strncpy( ob, "E01", GDB_BUFFERSIZE );
  else {
    switch ( type )
      {
      case 0:
        /* memory breakpoint */
        if ( bps->remove( address ) == 0 )
          strncpy( ob, "OK", GDB_BUFFERSIZE );
        else
          strncpy( ob, "E00", GDB_BUFFERSIZE );
        break;

      case 1:
        /* hardware breakpoint */
        ob[ 0 ] = 0; /* FIXME --- not yet supported */
        break;

      case 2:
        /* write watchpoint */
        ob[ 0 ] = 0; /* FIXME --- not yet supported */
        break;

      case 3:
        /* read watchpoint */
        ob[ 0 ] = 0; /* FIXME --- not yet supported */
        break;

      case 4:
        /* access watchpoint */
        ob[ 0 ] = 0; /* FIXME --- not yet supported */
        break;
      }
  }
}





/* GDB Specific Functions: ***************************************************/

void AC_GDB::connect() {
  struct sockaddr_in cliAddr, servAddr;
  int sd;

  /* Create Socket */
  if ( (sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
    perror("Cannot Open Socket");
    exit(-1);
  }

  /* Bind To Server Port */
  servAddr.sin_family = AF_INET;
  servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servAddr.sin_port = htons(this->port);

  { /* reuse address */
    int yes=1;
    if ( setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
      perror( "setsockopt" );
      exit(-1);
    }
  }

  printf("AC_GDB: binding to port %d\n", this->port);
  if(bind(sd, (struct sockaddr *) &servAddr, sizeof(servAddr))<0) {
    perror("bind");
    exit(-1);
  }

  listen(sd,5);

  /* Listen for a connection */
  {
    socklen_t cliLen;
    cliLen = sizeof(cliAddr);

    if ((this->sd = accept(sd, (struct sockaddr *) &cliAddr, &cliLen)) < 0 ) {
      perror("accept");
      exit(-1);
    }
  }

  connected = 1;
}


/*******************************************************************************
 * Process break point.                                                        *
 ******************************************************************************/

bool AC_GDB::stop(unsigned int decoded_pc) {
  if ( disabled ) return false;
  
  if ( first_time || step || bps->exists(decoded_pc))
    return true;
  return false;
}


void AC_GDB::process_bp() {
  if ( disabled ) return;
  first_time=0;
  
  snprintf( out_buffer, GDB_BUFFERSIZE, "S%02x", SIGTRAP );
  comm_putpacket(out_buffer);
  
  if ( ! connected ) return;

  while (1) {

    out_buffer[0] = 0;

    comm_getpacket(in_buffer);

    switch (in_buffer[0]) {
    case '?':
      /* "?": Return the reason simulator halted */
      snprintf( out_buffer, GDB_BUFFERSIZE, "S%02x", SIGTRAP );
      break;

    case 'g':
      /* "g": return the value of the CPU registers as hex data or ENN */
      reg_read( in_buffer, out_buffer );
      break;

    case 'G':
      /* "G": set the value of the CPU registers. */
      reg_write( in_buffer, out_buffer );
      break;

    case 'm':
      /* "mAA..AA,LLLL": Read LLLL bytes at address AA..AA as hex data or ENN*/
      mem_read( in_buffer, out_buffer );
      break;

    case 'M':
      /* "MAA..AA,LLLL:": Write LLLL bytes at address AA.AA return OK */
      mem_write( in_buffer, out_buffer );
      break;

    case 'c':
      /* "cAA..AA": continue at address AA..AA or same address if no AA..AA*/
      continue_execution( in_buffer, out_buffer );
      return;

    case 's':
      /* "sAA..AA": resume at address AA..AA or same address if no AA..AA */
      stepmode( in_buffer, out_buffer );
      return;

    case 0x03:
      /* Control-C: return control to gdb */
      cc( in_buffer, out_buffer );
      comm_putpacket( out_buffer );
      return;

    case 'k' :
      /* "k": kill */
      ac_stop();
      break;

    case 'Z':
      /* "ZT,AA..AA,LLLL": Insert breakpoint or watchpoint */
      break_insert( in_buffer, out_buffer );
      break;

    case 'z':
      /* "zT,AA..AA,LLLL": Remove breakpoint or watchpoint */
      break_remove( in_buffer, out_buffer );
      break;

    default:
      out_buffer[0] = 0; /* Null response */
    }

    comm_putpacket(out_buffer);
  }
}









/* Helper Functions: *********************************************************/

/* Copyright notice:
 *
 *              Most of this code was taken from: arch/mips/kernel/gdb-stub.c
 *
 * Original copyright:
 *
 *      Originally written by Glenn Engel, Lake Stevens Instrument Division
 *
 *      Contributed by HP Systems
 *
 *      Modified for SPARC by Stu Grossman, Cygnus Support.
 *
 *      Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
 *      Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
 *
 *      Copyright (C) 1995 Andreas Busse
 *
 *      Copyright (C) 2003 MontaVista Software Inc.
 *      Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
 */

int AC_GDB::hex(unsigned char ch)
{
  if (ch >= 'a' && ch <= 'f')
    return ch-'a'+10;
  if (ch >= '0' && ch <= '9')
    return ch-'0';
  if (ch >= 'A' && ch <= 'F')
    return ch-'A'+10;
  return -1;
}

void AC_GDB::comm_getpacket (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 = ( comm_getchar() & 0x7f ) ) != '$' );

    checksum = 0;
    xmitcsum = 255;
    count = 0;

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

    if ( count >= GDB_BUFFERSIZE )
      continue;

    buffer[ count ] = 0;

    if ( ch == '#' )
      {
        xmitcsum        = hex( comm_getchar() & 0x7f ) << 4;
        xmitcsum |= hex( comm_getchar() & 0x7f );

        if ( checksum != xmitcsum )
          comm_putchar( '-' ); /* failed checksum */
        else {
          comm_putchar( '+' ); /* successful transfer */

          /*
           * if a sequence char is present,
           * reply the sequence ID
           */
          if ( buffer[ 2 ] == ':' )
            {
              comm_putchar( buffer[0] );
              comm_putchar( buffer[1] );

              /*
               * remove sequence chars from buffer
               */
              count = strlen( buffer );
              for ( i = 3; i <= count; i ++ )
                buffer[ i - 3] = buffer[ i ];
            }
        }
      }
  }
  while ( checksum != xmitcsum );

  debug("received packet:" << buffer);
}



void AC_GDB::comm_putpacket(const char *buffer) {
  unsigned char checksum;
  int count;
  unsigned char ch;

  debug("                       out packet:" << buffer << endl);

  /*
   * $<packet info>#<checksum>.
   */

  do
    {
      comm_putchar( '$' );
      checksum = 0;
      count              = 0;

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

      comm_putchar( '#' );
      comm_putchar( hexchars[ checksum >> 4 ] );
      comm_putchar( hexchars[ checksum & 0xf ] );

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


int AC_GDB::comm_putchar(const char c) {
  return write( sd, &c, 1 );
}


char AC_GDB::comm_getchar() {
  char c;
  read( sd, &c, 1 );
  return(c);
}



void AC_GDB::disable() {
  this->disabled = 1;
}

void AC_GDB::enable() {
  this->disabled = 0;
}



int AC_GDB::is_disabled() {
  return (int) this->disabled;
}



void AC_GDB::set_port( int port ) {
  this->port = port;
}

int AC_GDB::get_port() {
  return this->port;
}

---