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 ()