Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// GDB Server Utilties: implementation

// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>

// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

// This file is part of the cycle accurate model of the OpenRISC 1000 based

// system-on-chip, ORPSoC, built using Verilator.

// This program is free software: you can redistribute it and/or modify it

// under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation, either version 3 of the License, or (at your

// option) any later version.

// This program 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 Lesser General Public

// License for more details.

// You should have received a copy of the GNU Lesser General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ----------------------------------------------------------------------------

// $Id: Utils.cpp 324 2009-03-07 09:42:52Z jeremy $

#include "Utils.h"

//-----------------------------------------------------------------------------

//!Utility to give the value of a hex char

//! @param[in] ch  A character representing a hexadecimal digit. Done as -1,

//!                for consistency with other character routines, which can

//!                use -1 as EOF.

//! @return  The value of the hex character, or -1 if the character is

//!          invalid.

//-----------------------------------------------------------------------------

uint8_t

Utils::char2Hex (int  c)

{

  return  ((c >= 'a') && (c <= 'f')) ? c - 'a' + 10 :

          ((c >= '0') && (c <= '9')) ? c - '0' :

          ((c >= 'A') && (c <= 'F')) ? c - 'A' + 10 : -1;

}       // char2Hex ()

//-----------------------------------------------------------------------------

//! Utility mapping a value to hex character

//! @param[in] d  A hexadecimal digit. Any non-hex digit returns a NULL char

//-----------------------------------------------------------------------------

const char

Utils::hex2Char (uint8_t  d)

{

  static const char map [] = "0123456789abcdef"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"

                             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

  return  map[d];

}       // hex2Char ()

//-----------------------------------------------------------------------------

//! Convert a register to a hex digit string

//! The supplied 32-bit value is converted to an 8 digit hex string. The

//! string is null terminated for convenience. The hex string follows the

//! universal printing convention: most significant digit on the left.

//! @param[in]  val  The value to convert

//! @param[out] buf  The buffer for the text string

//-----------------------------------------------------------------------------

void

Utils::reg2Hex (uint32_t  val,

                char     *buf)

{

  for (int  n = 7; n >= 0; n--)

    {

      buf[n] = hex2Char (val & 0xf);

      val /= 16;

    }

  buf[8] = 0;                    // Useful to terminate as string

}       // reg2hex ()

//-----------------------------------------------------------------------------

//! Convert a hex digit string to a register value

//! The supplied 8 digit hex string follows the universal printing convention:

//! most significant digit on the left. It is converted to a 32-bit value.

//! @param[in] buf  The buffer with the hex string

//! @return  The value to convert

//-----------------------------------------------------------------------------

uint32_t

Utils::hex2Reg (char *buf)

{

  uint32_t  val = 0;     // The result

  for (int  n = 0; n < 8; n++)

    {

      val = val * 16 + char2Hex (buf[n]);

    }

  return val;

}       // hex2reg ()

//-----------------------------------------------------------------------------

//! Convert an ASCII character string to pairs of hex digits

//! Both source and destination are null terminated.

//! @param[out] dest  Buffer to store the hex digit pairs (null terminated)

//! @param[in]  src   The ASCII string (null terminated)                      */

//-----------------------------------------------------------------------------

void

Utils::ascii2Hex (char *dest,

                  char *src)

{

  int  i;

  // Step through converting the source string

  for (i = 0; src[i] != '\0'; i++)

    {

      char  ch = src[i];

      dest[i * 2]     = hex2Char(ch >> 4 & 0xf);

      dest[i * 2 + 1] = hex2Char(ch      & 0xf);

    }

  dest[i * 2] = '\0';

}       // ascii2hex ()

//-----------------------------------------------------------------------------

//! Convert pairs of hex digits to an ASCII character string

//! Both source and destination are null terminated.

//! @param[out] dest  The ASCII string (null terminated)

//! @param[in]  src   Buffer holding the hex digit pairs (null terminated)

//-----------------------------------------------------------------------------

void

Utils::hex2Ascii (char *dest,

                  char *src)

{

  int  i;

  // Step through convering the source hex digit pairs

  for (i = 0; src[i * 2] != '\0' && src[i * 2 + 1] != '\0'; i++)

    {

      dest[i] = ((char2Hex (src[i * 2]) & 0xf) << 4) |

                 (char2Hex (src[i * 2 + 1]) & 0xf);

    }

  dest[i] = '\0';

}       // hex2ascii ()

//-----------------------------------------------------------------------------

//! "Unescape" RSP binary data

//! '#', '$' and '}' are escaped by preceding them by '}' and oring with 0x20.

//! This function reverses that, modifying the data in place.

//! @param[in] buf  The array of bytes to convert

//! @para[in]  len   The number of bytes to be converted

//! @return  The number of bytes AFTER conversion

//-----------------------------------------------------------------------------

int

Utils::rspUnescape (char *buf,

                    int   len)

{

  int  fromOffset = 0;           // Offset to source char

  int  toOffset   = 0;           // Offset to dest char

  while (fromOffset < len)

    {

      // Is it escaped

      if ( '}' == buf[fromOffset])

        {

          fromOffset++;

          buf[toOffset] = buf[fromOffset] ^ 0x20;

        }

      else

        {

          buf[toOffset] = buf[fromOffset];

        }

      fromOffset++;

      toOffset++;

    }

  return  toOffset;

}       // rspUnescape () */

//-----------------------------------------------------------------------------

//! Convert 32-bit value from host to target endianness

//! The target endianness is determined by the #define of TARGET_BIG_ENDIAN and

//! TARGET_LITTLE_ENDIAN. Not definining either is a compile time error.

//! @param[in] hostVal  The value in host endianness

//! @return  The value in target endianness

//-----------------------------------------------------------------------------

uint32_t

Utils::htotl (uint32_t hostVal)

{

  uint8_t  targetBytes[4];

#ifdef TARGET_BIG_ENDIAN

  targetBytes[0] = hostVal / 256 / 256 / 256;

  targetBytes[1] = hostVal / 256 / 256;

  targetBytes[2] = hostVal / 256;

  targetBytes[3] = hostVal;

#elif defined TARGET_LITTLE_ENDIAN

  targetBytes[0] = hostVal;

  targetBytes[1] = hostVal / 256;

  targetBytes[2] = hostVal / 256 / 256;

  targetBytes[3] = hostVal / 256 / 256 / 256;

#else

#error Must specify TARGET_BIG_ENDIAN or TARGET_LITTLE_ENDIAN

#endif

  return *((uint32_t *)targetBytes);

}       // htotl ()

//-----------------------------------------------------------------------------

//! Convert 32-bit value from target to host endianness

//! The target endianness is determined by the #define of TARGET_BIG_ENDIAN and

//! TARGET_LITTLE_ENDIAN. Not definining either is a compile time error.

//! @param[in] targetVal  The value in target endianness

//! @return  The value in target endianness

//-----------------------------------------------------------------------------

uint32_t

Utils::ttohl (uint32_t targetVal)

{

  uint8_t *targetBytes = (uint8_t *)(&targetVal);

  uint32_t hostVal;

#ifdef TARGET_BIG_ENDIAN

  hostVal =                 targetBytes[0];

  hostVal = hostVal * 256 + targetBytes[1];

  hostVal = hostVal * 256 + targetBytes[2];

  hostVal = hostVal * 256 + targetBytes[3];

#elif defined TARGET_LITTLE_ENDIAN

  hostVal =                 targetBytes[3];

  hostVal = hostVal * 256 + targetBytes[2];

  hostVal = hostVal * 256 + targetBytes[1];

  hostVal = hostVal * 256 + targetBytes[0];

#else

  #error Must specify TARGET_BIG_ENDIAN or TARGET_LITTLE_ENDIAN

#endif

  return  hostVal;

}       // ttohl ()