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