#include <SimValue.hh>

Collaboration diagram for SimValue:

Public Types
typedef DoubleWord	DoubleFloatWord

Public Member Functions
	SimValue ()

	SimValue (int width)

	SimValue (SLongWord value, int width)

	SimValue (const SimValue &source)

	~SimValue ()

int	width () const

void	setBitWidth (int width)

SimValue &	operator= (const SIntWord &source)

SimValue &	operator= (const UIntWord &source)

SimValue &	operator= (const SLongWord &source)

SimValue &	operator= (const ULongWord &source)

SimValue &	operator= (const HalfFloatWord &source)

SimValue &	operator= (const FloatWord &source)

SimValue &	operator= (const DoubleWord &source)

SimValue &	operator= (const SimValue &source)

void	deepCopy (const SimValue &source)

const SimValue	operator+ (const SIntWord &rightHand)

const SimValue	operator+ (const UIntWord &rightHand)

const SimValue	operator+ (const SLongWord &rightHand)

const SimValue	operator+ (const ULongWord &rightHand)

const SimValue	operator+ (const HalfFloatWord &rightHand)

const SimValue	operator+ (const FloatWord &rightHand)

const SimValue	operator+ (const DoubleWord &rightHand)

const SimValue	operator- (const SIntWord &rightHand)

const SimValue	operator- (const UIntWord &rightHand)

const SimValue	operator- (const SLongWord &rightHand)

const SimValue	operator- (const ULongWord &rightHand)

const SimValue	operator- (const HalfFloatWord &rightHand)

const SimValue	operator- (const FloatWord &rightHand)

const SimValue	operator- (const DoubleWord &rightHand)

const SimValue	operator/ (const SIntWord &rightHand)

const SimValue	operator/ (const UIntWord &rightHand)

const SimValue	operator/ (const SLongWord &rightHand)

const SimValue	operator/ (const ULongWord &rightHand)

const SimValue	operator/ (const HalfFloatWord &rightHand)

const SimValue	operator/ (const FloatWord &rightHand)

const SimValue	operator/ (const DoubleWord &rightHand)

const SimValue	operator* (const SIntWord &rightHand)

const SimValue	operator* (const UIntWord &rightHand)

const SimValue	operator* (const SLongWord &rightHand)

const SimValue	operator* (const ULongWord &rightHand)

const SimValue	operator* (const HalfFloatWord &rightHand)

const SimValue	operator* (const FloatWord &rightHand)

const SimValue	operator* (const DoubleWord &rightHand)

int	operator== (const SimValue &rightHand) const

int	operator== (const SIntWord &rightHand) const

int	operator== (const UIntWord &rightHand) const

int	operator== (const SLongWord &rightHand) const

int	operator== (const ULongWord &rightHand) const

int	operator== (const HalfFloatWord &rightHand) const

int	operator== (const FloatWord &rightHand) const

int	operator== (const DoubleWord &rightHand) const

int	intValue () const

unsigned int	unsignedValue () const

SIntWord	sIntWordValue () const

UIntWord	uIntWordValue () const

SLongWord	sLongWordValue () const

ULongWord	uLongWordValue () const

DoubleWord	doubleWordValue () const

FloatWord	floatWordValue () const

HalfFloatWord	halfFloatWordValue () const

TCEString	binaryValue () const

TCEString	hexValue (bool noHexIdentifier=false) const

Word	wordElement (size_t elementIndex) const

SIntWord	sIntWordElement (size_t elementIndex) const

UIntWord	uIntWordElement (size_t elementIndex) const

HalfWord	halfWordElement (size_t elementIndex) const

HalfFloatWord	halfFloatElement (size_t elementIndex) const

FloatWord	floatElement (size_t elementIndex) const

DoubleFloatWord	doubleFloatElement (size_t elementIndex) const

Byte	byteElement (size_t elementIndex) const

UIntWord	bitElement (size_t elementIndex) const

Word	element (size_t elementIndex, size_t elementWidth) const

void	setWordElement (size_t elementIndex, Word data)

void	setHalfWordElement (size_t elementIndex, HalfWord data)

void	setByteElement (size_t elementIndex, Byte data)

void	setBitElement (size_t elementIndex, UIntWord data)

void	setElement (size_t elementIndex, size_t elementWidth, Word data)

void	setHalfFloatElement (size_t elementIndex, HalfFloatWord data)

void	setFloatElement (size_t elementIndex, FloatWord data)

void	setDoubleFloatElement (size_t elementIndex, DoubleFloatWord data)

void	setValue (TCEString hexValue)

void	clearToZero (int bitWidth)

void	clearToZero ()

void	signExtendTo (int bitWidth)

void	zeroExtendTo (int bitWidth)

TCEString	dump () const

Public Attributes
Byte	rawData_ [SIMVALUE_MAX_BYTE_SIZE]
	Array that contains SimValue's underlaying bytes in little endian.

int	bitWidth_
	The bitwidth of the value.

Private Member Functions
template<typename T >
T	vectorElement (size_t elementIndex) const

template<typename T >
void	setVectorElement (size_t elementIndex, T data)

void	swapByteOrder (const Byte from, size_t byteCount, Byte to) const

Private Attributes
ULongWord	mask_
	Mask for masking extra bits when returning unsigned value.

Detailed Description

Class that represents values in simulation.

This class represents any data type that can be manipulated by operations of the target architecture template, and provides the interface to access the data in predefined types.

Values are always (regardless of the endianness of the machine) stored in little-endian convention in the rawData_ byte array. This is to model closer the internal registers and buses where the convention is to:

store the smallest vector elements to the smallest bit position, in the SimValue case, the smallest bytes in the storage array
store the elements in little-endian format

This is to avoid the need to implement two variations of function unit implementations, for both endianness modes.

This also means that big endian machines need endianness-aware load/stores as they need to swap the elements to the little-endian "internal format". However, as we lean towards using little-endian with vector machines (for example due to buggy LLVM BE/vector code gen), it means we usually use endianness-unaware "chunk" memory operations that can be uses both for scalar and vector data.

When a user wants to interpret SimValue as any primitive value (FloatWord, UIntWord, etc.), depending on the user's machine endianness the interpreted bytes are swapped correctly to be either in big-endian or little-endian convention. For instance, if the user has a big-endian machine and calls the uIntWordValue() function for a SimValue, which has the above value, it gets swapped so the OSAL operations can treat the result as a host integer to model the computation with.

The same swapping convention also occurs when a primitive value is assigned to SimValue. If the value to be assigned is in big-endian and its bytes are 0xabcd0000, the last four bytes in the SimValue are as 0x0000cdab.

SimValue users don't need to worry about the possible byte swapping since it is automatic and is done only if the user's machine is a little-endian machine. However, users shouldn't access the public rawData_ member directly unless they know exactly what they are doing, and always use the accessors for getting/setting lane data.

Definition at line 96 of file SimValue.hh.

Member Typedef Documentation

◆ DoubleFloatWord

typedef DoubleWord SimValue::DoubleFloatWord

Definition at line 99 of file SimValue.hh.

Constructor & Destructor Documentation

◆ SimValue() [1/4]

SimValue::SimValue ( )

Default constructor.

To allow creation of SimValue arrays. Constructs a SimValue with width of SIMULATOR_MAX_INTWORD_BITWIDTH bits.

Definition at line 47 of file SimValue.cc.

                   :
    mask_(~ULongWord(0)) {
 
    setBitWidth(SIMULATOR_MAX_LONGWORD_BITWIDTH);
}

References setBitWidth(), and SIMULATOR_MAX_LONGWORD_BITWIDTH.

Here is the call graph for this function:

◆ SimValue() [2/4]

SimValue::SimValue ( int width )

explicit

Constructor.

Parameters

width The bit width of the created SimValue.

Definition at line 58 of file SimValue.cc.

                            :
    mask_(~ULongWord(0)) {
 
    setBitWidth(width);
}

References setBitWidth(), and width().

Here is the call graph for this function:

◆ SimValue() [3/4]

SimValue::SimValue	(	SLongWord	value,
		int	width
	)

explicit

Constructor.

Parameters

value	The numeric value of this SimValue (in host endianness).
width	The bit width of the created SimValue.

Definition at line 71 of file SimValue.cc.

                                             :
    mask_(~ULongWord(0)) {
 
    setBitWidth(width);
 
    // Don't memcpy more than 8 bytes
    const int BYTE_COUNT =
        width < 64 ? (width + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH : 8;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(((const Byte*)&value), BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &value, BYTE_COUNT);
#endif
}

References BYTE_BITWIDTH, rawData_, setBitWidth(), swapByteOrder(), and width().

Here is the call graph for this function:

◆ SimValue() [4/4]

SimValue::SimValue ( const SimValue & source )

Copy constructor.

Parameters

source The source object from which to copy data.

Definition at line 93 of file SimValue.cc.

                                         {
    deepCopy(source);
}

References deepCopy().

Here is the call graph for this function:

◆ ~SimValue()

SimValue::~SimValue ( )

inline

Definition at line 104 of file SimValue.hh.

104{}

Member Function Documentation

◆ binaryValue()

TCEString SimValue::binaryValue ( ) const

Returns the value as a 2's complement (MSB left) binary string in ascii.

Definition at line 1121 of file SimValue.cc.

                            {
 
    const size_t BYTE_COUNT = bitWidth_ / BYTE_BITWIDTH;
 
    int remainBits = bitWidth_ % BYTE_BITWIDTH;
    TCEString binaryStr = "";
 
    if (remainBits > 0) {
        binaryStr += Conversion::toBinary(
            static_cast<unsigned int>(rawData_[BYTE_COUNT]),
            remainBits);
    }
 
    for (int i = BYTE_COUNT - 1; i >= 0; --i) {
        binaryStr += Conversion::toBinary(
            static_cast<unsigned int>(rawData_[i]), 8);
    }
 
    return binaryStr;
}

References bitWidth_, BYTE_BITWIDTH, rawData_, and Conversion::toBinary().

Referenced by TesterContext::toOutputFormat().

Here is the call graph for this function:

◆ bitElement()

UIntWord SimValue::bitElement ( size_t elementIndex ) const

Returns desired 1-bit bit element.

Definition at line 1288 of file SimValue.cc.

                                              {
    // Element index must not cross SimValue's bitwidth.
    assert((elementIndex+1) <= SIMD_WORD_WIDTH);
 
    const size_t OFFSET = elementIndex / BYTE_BITWIDTH;
    const size_t LEFT_SHIFTS = elementIndex % BYTE_BITWIDTH;
 
    Byte data = rawData_[OFFSET];
 
    if (data & (1 << LEFT_SHIFTS)) {
        return 1;
    } else {
        return 0;
    }
}

References assert, BYTE_BITWIDTH, rawData_, and SIMD_WORD_WIDTH.

Referenced by element(), and signExtendTo().

◆ byteElement()

Byte SimValue::byteElement ( size_t elementIndex ) const

Returns desired 8-bit byte element.

Definition at line 1274 of file SimValue.cc.

                                               {
    const size_t BYTE_COUNT = sizeof(Byte);
    const size_t OFFSET = elementIndex * BYTE_COUNT;
 
    // Element index must not cross SimValue's bitwidth.
    assert((elementIndex+1) <= (SIMVALUE_MAX_BYTE_SIZE / BYTE_COUNT));
    
    return rawData_[OFFSET];
}

References assert, rawData_, and SIMVALUE_MAX_BYTE_SIZE.

◆ clearToZero() [1/2]

void SimValue::clearToZero ( )

Sets all SimValue bytes to 0.

Definition at line 1516 of file SimValue.cc.

                      {
    clearToZero(SIMD_WORD_WIDTH);
}

References clearToZero(), and SIMD_WORD_WIDTH.

Referenced by clearToZero(), setBitWidth(), signExtendTo(), and zeroExtendTo().

Here is the call graph for this function:

◆ clearToZero() [2/2]

void SimValue::clearToZero ( int bitWidth )

Sets SimValue bytes to 0 for the given bitwidth.

Parameters

bitWidth The width that is to be nullified.

Definition at line 1504 of file SimValue.cc.

                                  {
    assert(bitWidth <= SIMD_WORD_WIDTH);
 
    const size_t BYTE_COUNT = (bitWidth + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    memset(rawData_, 0, BYTE_COUNT);
}

References assert, BYTE_BITWIDTH, rawData_, and SIMD_WORD_WIDTH.

◆ deepCopy()

void SimValue::deepCopy ( const SimValue & source )

Copies the source SimValue completely.

Parameters

source The source value.

Definition at line 307 of file SimValue.cc.

                                         {
 
    const size_t BYTE_COUNT =
        (source.bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    memcpy(rawData_, source.rawData_, BYTE_COUNT);
    bitWidth_ = source.bitWidth_;
    mask_ = source.mask_;
}

References bitWidth_, BYTE_BITWIDTH, mask_, and rawData_.

Referenced by OperationDAGBehavior::areValid(), OperationDAGBehavior::simulateTrigger(), and SimValue().

◆ doubleFloatElement()

SimValue::DoubleFloatWord SimValue::doubleFloatElement ( size_t elementIndex ) const

Definition at line 1266 of file SimValue.cc.

                                                      {
    return vectorElement<DoubleWord>(elementIndex);
}

◆ doubleWordValue()

DoubleWord SimValue::doubleWordValue ( ) const

Returns the SimValue as a host endian DoubleWord value.

Returns: DoubleWord value.

Definition at line 1052 of file SimValue.cc.

                                {
 
    const size_t BYTE_COUNT = sizeof(DoubleWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        DoubleWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    return cast.value;
}

References rawData_, and swapByteOrder().

Referenced by ExecutionTrace::addBusActivity(), SimulateDialog::formattedValue(), operator*(), operator+(), operator-(), operator/(), operator==(), and TesterContext::toOutputFormat().

Here is the call graph for this function:

◆ dump()

TCEString SimValue::dump ( ) const

Dumps raw data encoded in the SimValue in hexadecimal format.

Definition at line 1593 of file SimValue.cc.

                     {
    TCEString result = "width=";
    result += Conversion::toString(width());
    result += " mask=";
    result += Conversion::toBinary(mask_, 64);
    result += " data=0x";
 
    // Convert the raw data buffer to hex string values one byte at a time.
    // Also, remove "0x" from the front of the hex string for each hex value.
    for (int i = SIMVALUE_MAX_BYTE_SIZE - 1; i >= 0; --i) {
        unsigned int value =
            static_cast<unsigned int>(rawData_[i]);
        result += Conversion::toHexString(value, 2).substr(2);
    }
 
    return result;
}

References mask_, rawData_, SIMVALUE_MAX_BYTE_SIZE, Conversion::toBinary(), Conversion::toHexString(), Conversion::toString(), and width().

Here is the call graph for this function:

◆ element()

Word SimValue::element	(	size_t	elementIndex,
		size_t	elementWidth
	)		const

Get element function for arbitrary element width.

Values by width are stored in power of 2 byte boundaries (1, 2 or 4). elementWidth must be in range of (0, 32].

Definition at line 1311 of file SimValue.cc.

                                                                {
    // TODO: support 64-bit elements!
 
    assert(elementWidth != 0);
    assert(elementWidth <= 32);
 
    if (elementWidth == 1) {
        return bitElement(elementIndex);
    } else {
        const size_t BYTE_COUNT = elementWidth >= 8u ?
            MathTools::roundUpToPowerTwo((unsigned int)elementWidth)/8 : 1;
        const size_t OFFSET = elementIndex * BYTE_COUNT;
        const Word BITMASK =
            elementWidth < 32 ? ~(~Word(0) << elementWidth) : ~(Word(0));
        Word tmp;
 
#if HOST_BIGENDIAN == 1
        swapByteOrder(rawData_ + OFFSET, BYTE_COUNT, &tmp);
#else
        memcpy(&tmp, rawData_ + OFFSET, BYTE_COUNT);
#endif
        tmp &= BITMASK;
        return tmp;
    }
}

References assert, bitElement(), rawData_, MathTools::roundUpToPowerTwo(), and swapByteOrder().

Here is the call graph for this function:

◆ floatElement()

FloatWord SimValue::floatElement ( size_t elementIndex ) const

Definition at line 1261 of file SimValue.cc.

                                                {
    return vectorElement<FloatWord>(elementIndex);
}

◆ floatWordValue()

FloatWord SimValue::floatWordValue ( ) const

Returns the SimValue as a host endian FloatWord value.

Definition at line 1075 of file SimValue.cc.

                               {
 
    const size_t BYTE_COUNT = sizeof(FloatWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        FloatWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    return cast.value;
}

References rawData_, and swapByteOrder().

Referenced by SimulateDialog::formattedValue(), operator*(), operator+(), operator-(), operator/(), operator==(), and TesterContext::toOutputFormat().

Here is the call graph for this function:

◆ halfFloatElement()

HalfFloatWord SimValue::halfFloatElement ( size_t elementIndex ) const

Definition at line 1254 of file SimValue.cc.

                                                    {
    // Uses the same implementation as the integer version as
    // there is no native 'half' in C/C++.
    return HalfFloatWord(vectorElement<HalfWord>(elementIndex));
}

◆ halfFloatWordValue()

HalfFloatWord SimValue::halfFloatWordValue ( ) const

Returns the SimValue as a host endian HalfFloatWord value.

Definition at line 1098 of file SimValue.cc.

                                   {
 
    const size_t BYTE_COUNT = sizeof(uint16_t);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        uint16_t value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    return HalfFloatWord(cast.value);
}

References rawData_, and swapByteOrder().

Referenced by operator*(), operator+(), operator-(), operator/(), operator==(), and TesterContext::toOutputFormat().

Here is the call graph for this function:

◆ halfWordElement()

HalfWord SimValue::halfWordElement ( size_t elementIndex ) const

Returns desired 16-bit short integer word element in host endianness.

Definition at line 1249 of file SimValue.cc.

                                                   {
    return vectorElement<HalfWord>(elementIndex);
}

◆ hexValue()

TCEString SimValue::hexValue ( bool noHexIdentifier = false ) const

Returns the value as a big endian ordered (C-literal style) hex ascii string.

Parameters

noHexIdentifier Leaves "0x" prefix out if set to true.

Returns: SimValue bytes in hex format.

Definition at line 1150 of file SimValue.cc.

                                             {
    size_t hexNumbers = (bitWidth_ + 3) / 4;
    if (bitWidth_ <= 32) {
        if (noHexIdentifier) {
            return Conversion::toHexString(
                uIntWordValue(), hexNumbers).substr(2);
        } else {
            // TODO: what about SIMD? this only prints one word?
            return Conversion::toHexString(uLongWordValue(), hexNumbers);
        }
    }
 
    const size_t BYTE_COUNT =
        (bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
    const unsigned MSB_MASK = ~(0xfffffffffffffffful << (8-(BYTE_COUNT*8-bitWidth_)));
 
    TCEString hexStr;
    // Convert the raw data buffer to hex string values one byte at a time.
    // Also, remove "0x" from the front of the hex string for each hex value.
    for (int i = BYTE_COUNT - 1; i >= 0; --i) {
        unsigned int value = static_cast<unsigned int>(rawData_[i]);
        if (i == static_cast<int>(BYTE_COUNT - 1)) {
            value &= MSB_MASK;
        }
        hexStr += Conversion::toHexString(value, 2).substr(2);
    }
 
    // Remove extraneous zero digit from the front.
    hexStr = hexStr.substr(hexStr.size() - hexNumbers);
 
    if (!noHexIdentifier) hexStr.insert(0, "0x");
 
    return hexStr;
}

References bitWidth_, BYTE_BITWIDTH, rawData_, Conversion::toHexString(), uIntWordValue(), and uLongWordValue().

Referenced by BusTracker::handleEvent(), InfoRegistersCommand::registerDescription(), CompiledSimController::registerFileValue(), SimulationController::registerFileValue(), setValue(), and TesterContext::toOutputFormat().

Here is the call graph for this function:

◆ intValue()

int SimValue::intValue ( ) const

Returns SimValue as a sign extended host integer.

Definition at line 895 of file SimValue.cc.

                         {
 
    const size_t BYTE_COUNT = sizeof(int);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        int value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_ , BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    int bitWidth = (bitWidth_ > 32) ? 32 : bitWidth_;
    return MathTools::fastSignExtendTo(cast.value, bitWidth);
}

References bitWidth_, MathTools::fastSignExtendTo(), rawData_, and swapByteOrder().

Referenced by LoopAnalyzer::analyze(), OffsetAliasAnalyzer::analyze(), ITemplateBroker::assign(), ControlFlowGraph::buildMBBFromBB(), POMValidator::checkLongImmediates(), SimulatorFrontend::compareState(), BF2Scheduler::countLoopInvariantValueUsages(), MemoryAliasAnalyzer::detectConstantScale(), InfoImmediatesCommand::execute(), InfoPortsCommand::execute(), InfoSegmentsCommand::execute(), LoopAnalyzer::findEndCond(), MemoryAliasAnalyzer::findIncrement(), LoopAnalyzer::findInitAndUpdate(), DataDependenceGraph::findLoopIndexUpdate(), CompiledSimCodeGenerator::generateInstruction(), StackAliasAnalyzer::getStackOffset(), ProximRegisterWindow::loadImmediateUnit(), ProximRegisterWindow::loadRegisterFile(), main(), FUTestbenchGenerator::readValuesFromOutPorts(), MemoryAliasAnalyzer::searchLoopIndexBasedIncrement(), PreOptimizer::tryToRemoveEq(), PreOptimizer::tryToRemoveXor(), LoopAnalyzer::tryTrackCommonAncestor(), and ProximPortWindow::update().

Here is the call graph for this function:

◆ operator*() [1/7]

const SimValue SimValue::operator* ( const DoubleWord & rightHand )

Explicit multiplication operator to DoubleWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 760 of file SimValue.cc.

                                               {
    SimValue copy(*this);
    copy = doubleWordValue() * rightHand;
    return copy;
}

References doubleWordValue().

Here is the call graph for this function:

◆ operator*() [2/7]

const SimValue SimValue::operator* ( const FloatWord & rightHand )

Explicit multiplication operator to FloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 744 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = floatWordValue() * rightHand;
    return copy;
}

References floatWordValue().

Here is the call graph for this function:

◆ operator*() [3/7]

const SimValue SimValue::operator* ( const HalfFloatWord & rightHand )

Explicit multiply operator to HalfFloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 664 of file SimValue.cc.

                                                  {
    SimValue copy(*this);
    copy = halfFloatWordValue() * rightHand;
    return copy;
}

References halfFloatWordValue().

Here is the call graph for this function:

◆ operator*() [4/7]

const SimValue SimValue::operator* ( const SIntWord & rightHand )

Explicit multiplication operator to SIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 680 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = sIntWordValue() * rightHand;
    return copy;
}

References sIntWordValue().

Here is the call graph for this function:

◆ operator*() [5/7]

const SimValue SimValue::operator* ( const SLongWord & rightHand )

Explicit multiplication operator to SLongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 712 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = sLongWordValue() * rightHand;
    return copy;
}

References sLongWordValue().

Here is the call graph for this function:

◆ operator*() [6/7]

const SimValue SimValue::operator* ( const UIntWord & rightHand )

Explicit multiplication operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 696 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = uIntWordValue() * rightHand;
    return copy;
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator*() [7/7]

const SimValue SimValue::operator* ( const ULongWord & rightHand )

Explicit multiplication operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 728 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = uLongWordValue() * rightHand;
    return copy;
}

References uLongWordValue().

Here is the call graph for this function:

◆ operator+() [1/7]

const SimValue SimValue::operator+ ( const DoubleWord & rightHand )

Explicit addition operator to DoubleWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 423 of file SimValue.cc.

                                               {
    SimValue copy(*this);
    copy = doubleWordValue() + rightHand;
    return copy;
}

References doubleWordValue().

Here is the call graph for this function:

◆ operator+() [2/7]

const SimValue SimValue::operator+ ( const FloatWord & rightHand )

Explicit addition operator to FloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 407 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = floatWordValue() + rightHand;
    return copy;
}

References floatWordValue().

Here is the call graph for this function:

◆ operator+() [3/7]

const SimValue SimValue::operator+ ( const HalfFloatWord & rightHand )

Explicit addition operator to HalfFloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 391 of file SimValue.cc.

                                                  {
    SimValue copy(*this);
    copy = halfFloatWordValue() + rightHand;
    return copy;
}

References halfFloatWordValue().

Here is the call graph for this function:

◆ operator+() [4/7]

const SimValue SimValue::operator+ ( const SIntWord & rightHand )

Explicit addition operator to SIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 327 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = sIntWordValue() + rightHand;
    return copy;
}

References sIntWordValue().

Here is the call graph for this function:

◆ operator+() [5/7]

const SimValue SimValue::operator+ ( const SLongWord & rightHand )

Explicit addition operator to SlongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 359 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = sLongWordValue() + rightHand;
    return copy;
}

References sLongWordValue().

Here is the call graph for this function:

◆ operator+() [6/7]

const SimValue SimValue::operator+ ( const UIntWord & rightHand )

Explicit addition operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 343 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = uIntWordValue() + rightHand;
    return copy;
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator+() [7/7]

const SimValue SimValue::operator+ ( const ULongWord & rightHand )

Explicit addition operator to ULongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 375 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = uLongWordValue() + rightHand;
    return copy;
}

References uLongWordValue().

Here is the call graph for this function:

◆ operator-() [1/7]

const SimValue SimValue::operator- ( const DoubleWord & rightHand )

Explicit subtraction operator to DoubleWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 536 of file SimValue.cc.

                                               {
    SimValue copy(*this);
    copy = doubleWordValue() - rightHand;
    return copy;
}

References doubleWordValue().

Here is the call graph for this function:

◆ operator-() [2/7]

const SimValue SimValue::operator- ( const FloatWord & rightHand )

Explicit subtraction operator to FloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 520 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = floatWordValue() - rightHand;
    return copy;
}

References floatWordValue().

Here is the call graph for this function:

◆ operator-() [3/7]

const SimValue SimValue::operator- ( const HalfFloatWord & rightHand )

Explicit subtraction operator to HalfFloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 440 of file SimValue.cc.

                                                  {
    SimValue copy(*this);
    copy = halfFloatWordValue() - rightHand;
    return copy;
}

References halfFloatWordValue().

Here is the call graph for this function:

◆ operator-() [4/7]

const SimValue SimValue::operator- ( const SIntWord & rightHand )

Explicit subtraction operator to SIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 456 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = sIntWordValue() - rightHand;
    return copy;
}

References sIntWordValue().

Here is the call graph for this function:

◆ operator-() [5/7]

const SimValue SimValue::operator- ( const SLongWord & rightHand )

Explicit subtraction operator to SLongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 488 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = sLongWordValue() - rightHand;
    return copy;
}

References sLongWordValue().

Here is the call graph for this function:

◆ operator-() [6/7]

const SimValue SimValue::operator- ( const UIntWord & rightHand )

Explicit subtraction operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 472 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = uIntWordValue() - rightHand;
    return copy;
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator-() [7/7]

const SimValue SimValue::operator- ( const ULongWord & rightHand )

Explicit subtraction operator to ULongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 504 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = uLongWordValue() - rightHand;
    return copy;
}

References uLongWordValue().

Here is the call graph for this function:

◆ operator/() [1/7]

const SimValue SimValue::operator/ ( const DoubleWord & rightHand )

Explicit division operator to DoubleWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 648 of file SimValue.cc.

                                               {
    SimValue copy(*this);
    copy = doubleWordValue() / rightHand;
    return copy;
}

References doubleWordValue().

Here is the call graph for this function:

◆ operator/() [2/7]

const SimValue SimValue::operator/ ( const FloatWord & rightHand )

Explicit division operator to FloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 632 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = floatWordValue() / rightHand;
    return copy;
}

References floatWordValue().

Here is the call graph for this function:

◆ operator/() [3/7]

const SimValue SimValue::operator/ ( const HalfFloatWord & rightHand )

Explicit division operator to HalfFloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 552 of file SimValue.cc.

                                                  {
    SimValue copy(*this);
    copy = halfFloatWordValue() / rightHand;
    return copy;
}

References halfFloatWordValue().

Here is the call graph for this function:

◆ operator/() [4/7]

const SimValue SimValue::operator/ ( const SIntWord & rightHand )

Explicit division operator to SIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 568 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = sIntWordValue() / rightHand;
    return copy;
}

References sIntWordValue().

Here is the call graph for this function:

◆ operator/() [5/7]

const SimValue SimValue::operator/ ( const SLongWord & rightHand )

Explicit division operator to SLongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 600 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = sLongWordValue() / rightHand;
    return copy;
}

References sLongWordValue().

Here is the call graph for this function:

◆ operator/() [6/7]

const SimValue SimValue::operator/ ( const UIntWord & rightHand )

Explicit division operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 584 of file SimValue.cc.

                                             {
    SimValue copy(*this);
    copy = uIntWordValue() / rightHand;
    return copy;
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator/() [7/7]

const SimValue SimValue::operator/ ( const ULongWord & rightHand )

Explicit division operator to UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the addition.

Returns: The SimValue with the result of the operation.

Definition at line 616 of file SimValue.cc.

                                              {
    SimValue copy(*this);
    copy = uLongWordValue() / rightHand;
    return copy;
}

References uLongWordValue().

Here is the call graph for this function:

◆ operator=() [1/8]

SimValue & SimValue::operator= ( const DoubleWord & source )

Assignment operator for source value of type DoubleWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 258 of file SimValue.cc.

                                            {
 
    const size_t BYTE_COUNT = sizeof(DoubleWord);
 
    setBitWidth(BYTE_COUNT * BYTE_BITWIDTH);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References BYTE_BITWIDTH, rawData_, setBitWidth(), and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [2/8]

SimValue & SimValue::operator= ( const FloatWord & source )

Assignment operator for source value of type FloatWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 237 of file SimValue.cc.

                                           {
 
    const size_t BYTE_COUNT = sizeof(FloatWord);
 
    setBitWidth(BYTE_COUNT * BYTE_BITWIDTH);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References BYTE_BITWIDTH, rawData_, setBitWidth(), and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [3/8]

SimValue & SimValue::operator= ( const HalfFloatWord & source )

Assignment operator for source value of type HalfFloatWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 215 of file SimValue.cc.

                                               {
 
    const size_t BYTE_COUNT = sizeof(uint16_t);
    uint16_t data = source.getBinaryRep();
 
    setBitWidth(BYTE_COUNT * BYTE_BITWIDTH);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&data, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &data, BYTE_COUNT);
#endif
    return (*this);
}

References BYTE_BITWIDTH, HalfFloatWord::getBinaryRep(), rawData_, setBitWidth(), and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [4/8]

SimValue & SimValue::operator= ( const SimValue & source )

Assignment operator for source value of type SimValue.

Note: No sign extension is done in case the destination width differs from the source width.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 282 of file SimValue.cc.

                                          {
 
    const size_t DST_BYTE_COUNT =
        (bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
    const size_t SRC_BYTE_COUNT =
        (source.bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    memcpy(rawData_, source.rawData_, SRC_BYTE_COUNT);
    if (SRC_BYTE_COUNT < DST_BYTE_COUNT) {
        memset(rawData_+SRC_BYTE_COUNT, 0, DST_BYTE_COUNT-SRC_BYTE_COUNT);
    } else if (bitWidth_ % BYTE_BITWIDTH) {
        const unsigned bitsInMSB = bitWidth_ % BYTE_BITWIDTH;
        const Byte msbBitMask = static_cast<Byte>((1 << bitsInMSB) - 1);
        rawData_[DST_BYTE_COUNT-1] &= msbBitMask;
    }
 
    return (*this);
}

References bitWidth_, BYTE_BITWIDTH, and rawData_.

◆ operator=() [5/8]

SimValue & SimValue::operator= ( const SIntWord & source )

Assignment operator for source value of type SIntWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 138 of file SimValue.cc.

                                          {
 
    const size_t BYTE_COUNT = sizeof(SIntWord);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References rawData_, and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [6/8]

SimValue & SimValue::operator= ( const SLongWord & source )

Assignment operator for source value of type SLongWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 176 of file SimValue.cc.

                                           {
 
    const size_t BYTE_COUNT = sizeof(SLongWord);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References rawData_, and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [7/8]

SimValue & SimValue::operator= ( const UIntWord & source )

Assignment operator for source value of type UIntWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 157 of file SimValue.cc.

                                          {
 
    const size_t BYTE_COUNT = sizeof(UIntWord);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References rawData_, and swapByteOrder().

Here is the call graph for this function:

◆ operator=() [8/8]

SimValue & SimValue::operator= ( const ULongWord & source )

Assignment operator for source value of type ULongWord.

Parameters

source The source value.

Returns: Reference to itself.

Definition at line 195 of file SimValue.cc.

                                           {
 
    const size_t BYTE_COUNT = sizeof(ULongWord);
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((const Byte*)&source, BYTE_COUNT, rawData_);
#else
    memcpy(rawData_, &source, BYTE_COUNT);
#endif
    return (*this);
}

References rawData_, and swapByteOrder().

Here is the call graph for this function:

◆ operator==() [1/8]

int SimValue::operator== ( const DoubleWord & rightHand ) const

Explicit equality operator for DoubleWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 887 of file SimValue.cc.

                                                      {
    return doubleWordValue() == rightHand;
}

References doubleWordValue().

Here is the call graph for this function:

◆ operator==() [2/8]

int SimValue::operator== ( const FloatWord & rightHand ) const

Explicit equality operator for FloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 872 of file SimValue.cc.

                                                     {
    return floatWordValue() == rightHand;
}

References floatWordValue().

Here is the call graph for this function:

◆ operator==() [3/8]

int SimValue::operator== ( const HalfFloatWord & rightHand ) const

Explicit equality operator for HalfFloatWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 857 of file SimValue.cc.

                                                         {
    return halfFloatWordValue().getBinaryRep() == rightHand.getBinaryRep();
}

References HalfFloatWord::getBinaryRep(), and halfFloatWordValue().

Here is the call graph for this function:

◆ operator==() [4/8]

int SimValue::operator== ( const SimValue & rightHand ) const

Explicit equality operator for SimValue type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Note: This compares only the first value as a 32bit uintword, thus does not work for vectors that exceed that width.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Todo:: Should this be changed to comparison between bytes from the whole bitwidth?

Definition at line 780 of file SimValue.cc.

                                                    {
    /// @todo Should this be changed to comparison between bytes from the
    /// whole bitwidth?
    return uIntWordValue() == rightHand.uIntWordValue();
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator==() [5/8]

int SimValue::operator== ( const SIntWord & rightHand ) const

Explicit equality operator for SIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 797 of file SimValue.cc.

                                                    {
    return sIntWordValue() == rightHand;
}

References sIntWordValue().

Here is the call graph for this function:

◆ operator==() [6/8]

int SimValue::operator== ( const SLongWord & rightHand ) const

Explicit equality operator for SLongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 827 of file SimValue.cc.

                                                     {
    return sLongWordValue() == rightHand;
}

References sLongWordValue().

Here is the call graph for this function:

◆ operator==() [7/8]

int SimValue::operator== ( const UIntWord & rightHand ) const

Explicit equality operator for UIntWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 812 of file SimValue.cc.

                                                    {
    return uIntWordValue() == rightHand;
}

References uIntWordValue().

Here is the call graph for this function:

◆ operator==() [8/8]

int SimValue::operator== ( const ULongWord & rightHand ) const

Explicit equality operator for ULongWord type.

These operators are defined to avoid ambiguous overload because of built-in operators.

Parameters

rightHand The right hand side of the comparison.

Returns: Reference to itself.

Definition at line 842 of file SimValue.cc.

                                                     {
    return uLongWordValue() == rightHand;
}

References uLongWordValue().

Here is the call graph for this function:

◆ setBitElement()

void SimValue::setBitElement	(	size_t	elementIndex,
		UIntWord	data
	)

Sets bit element at a certain index to given value.

Parameters

elementIndex	Bit element index.
data	Bit element data.

Definition at line 1397 of file SimValue.cc.

                                                          {
    // Element index must not cross SimValue's bitwidth.
    assert((elementIndex+1) <= SIMD_WORD_WIDTH);
 
    const size_t OFFSET = elementIndex / BYTE_BITWIDTH;
    const size_t LEFT_SHIFTS = elementIndex % BYTE_BITWIDTH;
 
    Byte byte = rawData_[OFFSET];
 
    if (data == 0) {
        byte = byte & (~(1 << LEFT_SHIFTS));
    } else {
        byte = byte | (1 << LEFT_SHIFTS);
    }
    
    rawData_[OFFSET] = byte;
}

References assert, BYTE_BITWIDTH, rawData_, and SIMD_WORD_WIDTH.

Referenced by setElement().

◆ setBitWidth()

void SimValue::setBitWidth ( int width )

Sets SimValue's bitwidth and clears bytes to 0 for the whole width.

Parameters

width The new bit width.

Definition at line 113 of file SimValue.cc.

                               {
    assert(width <= SIMD_WORD_WIDTH);
 
    bitWidth_ = width;
    if (BYTE_BITWIDTH * sizeof(mask_) > static_cast<size_t>(width)) {
        mask_ = ~((~ULongWord(0)) << bitWidth_);
    }
 
    const int BYTE_COUNT = (width + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    if (static_cast<size_t>(BYTE_COUNT) > sizeof(DoubleWord)) {
        clearToZero(width);
    } else {
        clearToZero(BYTE_BITWIDTH * sizeof(DoubleWord));
    }
}

References assert, bitWidth_, BYTE_BITWIDTH, clearToZero(), mask_, SIMD_WORD_WIDTH, and width().

Referenced by CmdMem::execute(), operator=(), operator=(), operator=(), SimValue(), SimValue(), SimValue(), and SimpleOperationExecutor::startOperation().

Here is the call graph for this function:

◆ setByteElement()

void SimValue::setByteElement	(	size_t	elementIndex,
		Byte	data
	)

Definition at line 1386 of file SimValue.cc.

                                                       {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ setDoubleFloatElement()

void SimValue::setDoubleFloatElement	(	size_t	elementIndex,
		DoubleFloatWord	data
	)

Definition at line 1381 of file SimValue.cc.

                                                                         {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ setElement()

void SimValue::setElement	(	size_t	elementIndex,
		size_t	elementWidth,
		Word	data
	)

Set element function for arbitrary element width.

Values by width are stored in power of 2 byte boundaries (1, 2 or 4). elementWidth must be in range of (0, 32].

Definition at line 1422 of file SimValue.cc.

                                                                        {
    assert(elementWidth != 0);
    if (elementWidth == 1) {
        setBitElement(elementIndex, data);
    } else {
        const size_t BYTE_COUNT =
            elementWidth >= 8u ?
                MathTools::roundUpToPowerTwo((unsigned int)elementWidth)/8 : 1;
        const size_t OFFSET = elementIndex * BYTE_COUNT;
 
        // Element index must not cross SimValue's bitwidth.
        assert((elementIndex+1) <= (SIMVALUE_MAX_BYTE_SIZE / BYTE_COUNT));
        // Cut excess bits from data
        Word BITMASK = ~Word(0);
        if (elementWidth < sizeof(Word)*8) {
            BITMASK = ~(~Word(0) << elementWidth);
        }
 
        Word tmp_data = data & BITMASK;
#if HOST_BIGENDIAN == 1
        swapByteOrder((Byte*)&tmp_data, BYTE_COUNT, rawData_ + OFFSET);
#else
        memcpy(rawData_ + OFFSET, &tmp_data, BYTE_COUNT);
#endif
    }
}

References assert, rawData_, MathTools::roundUpToPowerTwo(), setBitElement(), SIMVALUE_MAX_BYTE_SIZE, and swapByteOrder().

Here is the call graph for this function:

◆ setFloatElement()

void SimValue::setFloatElement	(	size_t	elementIndex,
		FloatWord	data
	)

Definition at line 1376 of file SimValue.cc.

                                                             {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ setHalfFloatElement()

void SimValue::setHalfFloatElement	(	size_t	elementIndex,
		HalfFloatWord	data
	)

Definition at line 1371 of file SimValue.cc.

                                                                     {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ setHalfWordElement()

void SimValue::setHalfWordElement	(	size_t	elementIndex,
		HalfWord	data
	)

Sets half word (a.k.a. short 16-bit integer) element at a certain index to given value.

Parameters

elementIndex	Half word element index.
data	Half word element data.

Definition at line 1366 of file SimValue.cc.

                                                               {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ setValue()

void SimValue::setValue ( TCEString hexValue )

Sets SimValue to correspond the hex value.

Given hex string must be in big-endian order when it is given. For instance, if the user wants to set integer value 5 through this function, the function should be called "setValue("0x00000005");". Add leading zeroes if you want to clear bytes before the byte that has value 5.

Parameters

hexValue New value in hex format.

Definition at line 1460 of file SimValue.cc.

                                     {
    if (hexValue.size() > 2 && hexValue[0] == '0' && hexValue[1] == 'x') {
        hexValue = hexValue.substr(2); // Remove "0x."
    }
 
    const size_t VALUE_BITWIDTH = hexValue.size() * 4;
 
    // stretch the SimValue to the hex value bit width in case
    // this is an initialization
    if (bitWidth_ == 0) bitWidth_ = VALUE_BITWIDTH;
 
    size_t paddingBytes = 0;
    // Check the hex string value is legal.
    if (VALUE_BITWIDTH > SIMD_WORD_WIDTH) {
        throw NumberFormatException(
            __FILE__, __LINE__, __func__, "Too wide value.");
    } else if (VALUE_BITWIDTH == 0) {
        throw NumberFormatException(
            __FILE__, __LINE__, __func__, "Input value is empty.");
    } else if (VALUE_BITWIDTH > (size_t)bitWidth_) {
        // Add padding zero bytes in case the hexValue defines less
        // bytes than the width of the value.
        paddingBytes = (VALUE_BITWIDTH - bitWidth_) / 8;
        for (size_t i = 0; i < paddingBytes; ++i)
            rawData_[VALUE_BITWIDTH / 8 + i] = 0;
    }
    Byte bigEndianData[SIMVALUE_MAX_BYTE_SIZE];
    Conversion::toRawData(hexValue, bigEndianData);
 
    // because the hexValues are 4bits each they might not fill exact
    // bytes, thus we need to round up to consume an extra byte for
    // remaining 4bits
    int byteWidth = VALUE_BITWIDTH / 8;
    if (VALUE_BITWIDTH % 8 != 0) ++byteWidth;
 
    swapByteOrder(bigEndianData, byteWidth, rawData_);
}

References __func__, bitWidth_, hexValue(), rawData_, SIMD_WORD_WIDTH, SIMVALUE_MAX_BYTE_SIZE, swapByteOrder(), and Conversion::toRawData().

Here is the call graph for this function:

◆ setVectorElement()

template<typename T >

void SimValue::setVectorElement	(	size_t	elementIndex,
		T	data
	)

private

Definition at line 1339 of file SimValue.cc.

                                                      {
    const size_t BYTE_COUNT = sizeof(T);
    const size_t OFFSET = elementIndex * BYTE_COUNT;
 
    // Element index must not cross SimValue's bitwidth.
    assert((elementIndex+1) <= (SIMVALUE_MAX_BYTE_SIZE / BYTE_COUNT));
 
#if HOST_BIGENDIAN == 1
    swapByteOrder((Byte*)&data, BYTE_COUNT, rawData_ + OFFSET);
#else
    memcpy(rawData_ + OFFSET, &data, BYTE_COUNT);
#endif   
}

References assert, rawData_, SIMVALUE_MAX_BYTE_SIZE, and swapByteOrder().

Referenced by setByteElement(), setDoubleFloatElement(), setFloatElement(), setHalfFloatElement(), setHalfWordElement(), and setWordElement().

Here is the call graph for this function:

◆ setWordElement()

void SimValue::setWordElement	(	size_t	elementIndex,
		Word	data
	)

Definition at line 1354 of file SimValue.cc.

                                                       {
    setVectorElement(elementIndex, data);
}

References setVectorElement().

Here is the call graph for this function:

◆ signExtendTo()

void SimValue::signExtendTo ( int bitWidth )

Overwrites all bits that do not fit in the given bit width with the sign bit (the bit at position width - 1).

This operation corresponds to reinterpreting the value as a signed word of given bit width.

Parameters

bitWidth Number of meaningful bits in the given integer.

Exceptions

OutOfRange If width > value size

Definition at line 1531 of file SimValue.cc.

                                   {
    if (bitWidth > SIMD_WORD_WIDTH) {
        throw OutOfRange(__FILE__, __LINE__, __func__);
    }
 
    if (bitWidth <= 0) {
        clearToZero();
        return;
    }
 
    const size_t FIRST_BYTE = (bitWidth + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
    const size_t BYTE_COUNT = (bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    rawData_[FIRST_BYTE-1] = MathTools::fastSignExtendTo(
                                        static_cast<int>(rawData_[FIRST_BYTE-1]),
                                        ((bitWidth-1)%BYTE_BITWIDTH)+1);
 
    if (BYTE_COUNT > FIRST_BYTE) { // Fill remaining bytes with sign bit
        if (bitElement(bitWidth-1) == 0) {
            memset(rawData_+FIRST_BYTE, 0, BYTE_COUNT-FIRST_BYTE);
        } else {
            memset(rawData_+FIRST_BYTE, -1, BYTE_COUNT-FIRST_BYTE);
        }
    }
}

References __func__, bitElement(), bitWidth_, BYTE_BITWIDTH, clearToZero(), MathTools::fastSignExtendTo(), rawData_, and SIMD_WORD_WIDTH.

Referenced by SimProgramBuilder::processMove().

Here is the call graph for this function:

◆ sIntWordElement()

SIntWord SimValue::sIntWordElement ( size_t elementIndex ) const

Returns desired element at given index as signed integer.

Definition at line 1227 of file SimValue.cc.

                                                   {
    union CastUnion {
        Word uWord;
        SIntWord sWord;
    } cast;
    cast.uWord = wordElement(elementIndex);
    return cast.sWord;
}

References wordElement().

Here is the call graph for this function:

◆ sIntWordValue()

SIntWord SimValue::sIntWordValue ( ) const

Returns the SimValue as SIntWord value.

Definition at line 944 of file SimValue.cc.

                              {
 
    const size_t BYTE_COUNT = sizeof(SIntWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        SIntWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
 
    if ((unsigned)bitWidth_ >= sizeof(SIntWord) * BYTE_BITWIDTH) {
        return cast.value;
    } else {
        return MathTools::fastSignExtendTo(cast.value, bitWidth_);
    }
}

References bitWidth_, BYTE_BITWIDTH, MathTools::fastSignExtendTo(), rawData_, and swapByteOrder().

Referenced by ProximBusDetailsCmd::Do(), ProximIUDetailsCmd::Do(), ExecutableMove::evaluateGuard(), SimulateDialog::formattedValue(), ProgramImageGenerator::generateProgramImage(), operator*(), operator+(), operator-(), operator/(), and operator==().

Here is the call graph for this function:

◆ sLongWordValue()

SLongWord SimValue::sLongWordValue ( ) const

Returns the SimValue as SIntWord value.

Returns: SIntWord value.

Definition at line 997 of file SimValue.cc.

                               {
 
    const size_t BYTE_COUNT = sizeof(SLongWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        SLongWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
 
    if ((unsigned)bitWidth_ >= sizeof(SLongWord) * BYTE_BITWIDTH) {
        return cast.value;
    } else {
        return MathTools::fastSignExtendTo(cast.value, bitWidth_);
    }
}

References bitWidth_, BYTE_BITWIDTH, MathTools::fastSignExtendTo(), rawData_, and swapByteOrder().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), BuslessExecutableMove::executeWrite(), operator*(), operator+(), operator-(), operator/(), operator==(), SimProgramBuilder::processMove(), InfoRegistersCommand::registerDescription(), MachineConnectivityCheck::requiredImmediateWidth(), LongImmediateRegisterState::setValue(), TesterContext::toOutputFormat(), DisassemblyImmediate::toString(), and DisassemblyImmediateAssignment::toString().

Here is the call graph for this function:

◆ swapByteOrder()

void SimValue::swapByteOrder	(	const Byte *	from,
		size_t	byteCount,
		Byte *	to
	)		const

private

Todo:: This currently works, but there could be more optimal 8-byte, 4-byte and 2-byte swapper functions for 2/4/8 byte swaps. The more optimal swappers would load all bytes to 8, 4 or 2-byte values and shift invidivual bytes to their correct places, which would reduce memory accesses. Or use some intrincs for optimal execution and better code density.

Copies the byte order from source array in opposite order to target array.

Note: Caller is responsible for making sure both input pointers have enough allocated memory.

Parameters

from	Array from which the bytes are copied.
byteCount	How many bytes are copied.
to	Array to which the bytes are copied in opposite order.

Definition at line 1621 of file SimValue.cc.

                                                        {
 
    assert (from != to);
    for (size_t i = 0; i < byteCount; ++i) {
        to[byteCount - 1 - i] = from[i];
    }
}

References assert.

Referenced by doubleWordValue(), element(), floatWordValue(), halfFloatWordValue(), intValue(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), setElement(), setValue(), setVectorElement(), SimValue(), sIntWordValue(), sLongWordValue(), uIntWordValue(), uLongWordValue(), unsignedValue(), and vectorElement().

◆ uIntWordElement()

UIntWord SimValue::uIntWordElement ( size_t elementIndex ) const

Returns desired element at given index as unsigned integer.

Definition at line 1240 of file SimValue.cc.

                                                   {
    return wordElement(elementIndex);
}

References wordElement().

Here is the call graph for this function:

◆ uIntWordValue()

UIntWord SimValue::uIntWordValue ( ) const

Returns the SimValue as host endian UIntWord value.

Definition at line 972 of file SimValue.cc.

                              {
 
    const size_t BYTE_COUNT = sizeof(UIntWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        UIntWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    return cast.value & mask_;
}

References mask_, rawData_, and swapByteOrder().

Referenced by ExecutionTrace::addBusActivity(), ProximFUDetailsCmd::Do(), CodeCompressorPlugin::encodeImmediateTerminal(), CodeCompressorPlugin::encodeLongImmediate(), SimulateDialog::formattedValue(), hexValue(), operator*(), operator+(), operator-(), operator/(), operator==(), operator==(), and SimulationInfoDialog::updateList().

Here is the call graph for this function:

◆ uLongWordValue()

ULongWord SimValue::uLongWordValue ( ) const

Returns the SimValue as an ULongWord.

Returns: UIntWord value.

Definition at line 1027 of file SimValue.cc.

                               {
 
    const size_t BYTE_COUNT = sizeof(ULongWord);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        ULongWord value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
    return cast.value & mask_;
}

References mask_, rawData_, and swapByteOrder().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), POMDisassembler::createMove(), hexValue(), operator*(), operator+(), operator-(), operator/(), operator==(), SimProgramBuilder::processMove(), MachineConnectivityCheck::requiredImmediateWidth(), LongImmediateRegisterState::setValue(), TesterContext::toOutputFormat(), DisassemblyImmediate::toString(), and DisassemblyImmediateAssignment::toString().

Here is the call graph for this function:

◆ unsignedValue()

unsigned int SimValue::unsignedValue ( ) const

Returns SimValue as a zero extended unsigned host integer.

Definition at line 919 of file SimValue.cc.

                              {
 
    const size_t BYTE_COUNT = sizeof(unsigned int);
 
    union CastUnion {
        Byte bytes[BYTE_COUNT];
        unsigned int value;
    };
 
    CastUnion cast;
 
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_, BYTE_COUNT);
#endif
 
    int bitWidth = (bitWidth_ > 32) ? 32 : bitWidth_;
    return MathTools::fastZeroExtendTo(cast.value, bitWidth);
}

References bitWidth_, MathTools::fastZeroExtendTo(), rawData_, and swapByteOrder().

Referenced by StaticProgramAnalyzer::addProgram(), TTAProgram::TerminalAddress::address(), ITemplateBroker::assign(), POMValidator::checkLongImmediates(), TTAProgram::ProgramWriter::createCodeSection(), RFTestbenchGenerator::createStimulus(), ProximFUPortDetailsCmd::Do(), ProximRFDetailsCmd::Do(), CompiledSimCodeGenerator::generateInstruction(), ConstantAliasAnalyzer::getConstantAddress(), BUBasicBlockScheduler::handleLoopDDG(), ProximRegisterWindow::loadImmediateUnit(), ProximRegisterWindow::loadRegisterFile(), CompiledSimSymbolGenerator::moveOperandSymbol(), BasicBlockScheduler::scheduleMove(), and ProximPortWindow::update().

Here is the call graph for this function:

◆ vectorElement()

template<typename T >

T SimValue::vectorElement ( size_t elementIndex ) const

private

Definition at line 1187 of file SimValue.cc.

                                                 {
    const size_t BYTE_COUNT = sizeof(T);
    const size_t OFFSET = elementIndex * BYTE_COUNT;
 
    // Element index must not cross SimValue's bitwidth.
    assert((elementIndex+1) <= (SIMVALUE_MAX_BYTE_SIZE / BYTE_COUNT));
 
    union CastUnion {
        Byte bytes[sizeof(T)];
        T value;
    };
 
    CastUnion cast;
    
#if HOST_BIGENDIAN == 1
    swapByteOrder(rawData_ + OFFSET, BYTE_COUNT, cast.bytes);
#else
    memcpy(cast.bytes, rawData_ + OFFSET, BYTE_COUNT);
#endif
    return cast.value;
}

References assert, rawData_, SIMVALUE_MAX_BYTE_SIZE, and swapByteOrder().

Here is the call graph for this function:

◆ width()

int SimValue::width ( ) const

Returns the bit width of the SimValue.

Returns: The bit width.

Definition at line 103 of file SimValue.cc.

                      {
    return bitWidth_;
}

References bitWidth_.

Referenced by ITemplateBroker::assign(), POMValidator::checkLongImmediates(), dump(), BUBasicBlockScheduler::handleLoopDDG(), BasicBlockScheduler::scheduleMove(), setBitWidth(), LongImmediateRegisterState::setValue(), SimValue(), SimValue(), TesterContext::toOutputFormat(), DisassemblyImmediate::toString(), BusState::width(), and FUTestbenchGenerator::writeInputPortStimulus().

◆ wordElement()

Word SimValue::wordElement ( size_t elementIndex ) const

Returns the desired 32-bit word element in host endianness.

The element ordering of SimValue storage is always the memory order, first vector elements in the first locations.

Parameters

elementIndex Index of the element (from 0 upwards).

Returns: Word element.

Definition at line 1219 of file SimValue.cc.

                                               {
    return vectorElement<Word>(elementIndex);
}

Referenced by sIntWordElement(), and uIntWordElement().

◆ zeroExtendTo()

void SimValue::zeroExtendTo ( int bitWidth )

Overwrites all bits that do not fit in the given bit width with 0

This operation corresponds to reinterpreting the value as an unsigned word of given bit width.

Parameters

bitWidth Number of meaningful bits in the given integer.

Exceptions

OutOfRange If width > value size

Definition at line 1567 of file SimValue.cc.

                                   {
    if (bitWidth > SIMD_WORD_WIDTH) {
        throw OutOfRange(__FILE__, __LINE__, __func__);
    }
 
    if (bitWidth <= 0) {
        clearToZero();
        return;
    }
 
    const size_t FIRST_BYTE = (bitWidth + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
    const size_t BYTE_COUNT = (bitWidth_ + (BYTE_BITWIDTH - 1)) / BYTE_BITWIDTH;
 
    rawData_[FIRST_BYTE-1] = MathTools::fastZeroExtendTo(
                                        static_cast<int>(rawData_[FIRST_BYTE-1]),
                                        ((bitWidth-1)%BYTE_BITWIDTH)+1);
 
    if (BYTE_COUNT > FIRST_BYTE) { // Fill remaining bytes with 0
        memset(rawData_+FIRST_BYTE, 0, BYTE_COUNT-FIRST_BYTE);
    }
}

References __func__, bitWidth_, BYTE_BITWIDTH, clearToZero(), MathTools::fastZeroExtendTo(), rawData_, and SIMD_WORD_WIDTH.

Referenced by SimProgramBuilder::processMove().

Here is the call graph for this function:

Member Data Documentation

◆ bitWidth_

int SimValue::bitWidth_

The bitwidth of the value.

Definition at line 205 of file SimValue.hh.

Referenced by binaryValue(), deepCopy(), hexValue(), intValue(), operator=(), setBitWidth(), setValue(), signExtendTo(), sIntWordValue(), sLongWordValue(), unsignedValue(), width(), and zeroExtendTo().

◆ mask_

ULongWord SimValue::mask_

private

Mask for masking extra bits when returning unsigned value.

Definition at line 223 of file SimValue.hh.

Referenced by deepCopy(), dump(), setBitWidth(), uIntWordValue(), and uLongWordValue().

◆ rawData_

Byte SimValue::rawData_[SIMVALUE_MAX_BYTE_SIZE]

Array that contains SimValue's underlaying bytes in little endian.

Definition at line 202 of file SimValue.hh.

Referenced by binaryValue(), bitElement(), byteElement(), clearToZero(), deepCopy(), doubleWordValue(), dump(), element(), floatWordValue(), halfFloatWordValue(), hexValue(), intValue(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), operator=(), setBitElement(), setElement(), setValue(), setVectorElement(), signExtendTo(), SimValue(), sIntWordValue(), sLongWordValue(), uIntWordValue(), uLongWordValue(), unsignedValue(), vectorElement(), and zeroExtendTo().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DoubleFloatWord

Constructor & Destructor Documentation

◆ SimValue() [1/4]

◆ SimValue() [2/4]

◆ SimValue() [3/4]

◆ SimValue() [4/4]

◆ ~SimValue()

Member Function Documentation

◆ binaryValue()

◆ bitElement()

◆ byteElement()

◆ clearToZero() [1/2]

◆ clearToZero() [2/2]

◆ deepCopy()

◆ doubleFloatElement()

◆ doubleWordValue()

◆ dump()

◆ element()

◆ floatElement()

◆ floatWordValue()

◆ halfFloatElement()

◆ halfFloatWordValue()

◆ halfWordElement()

◆ hexValue()

◆ intValue()

◆ operator*() [1/7]

◆ operator*() [2/7]

◆ operator*() [3/7]

◆ operator*() [4/7]

◆ operator*() [5/7]

◆ operator*() [6/7]

◆ operator*() [7/7]

◆ operator+() [1/7]

◆ operator+() [2/7]

◆ operator+() [3/7]

◆ operator+() [4/7]

◆ operator+() [5/7]

◆ operator+() [6/7]

◆ operator+() [7/7]

◆ operator-() [1/7]

◆ operator-() [2/7]

◆ operator-() [3/7]

◆ operator-() [4/7]

◆ operator-() [5/7]

◆ operator-() [6/7]

◆ operator-() [7/7]

◆ operator/() [1/7]

◆ operator/() [2/7]

◆ operator/() [3/7]

◆ operator/() [4/7]

◆ operator/() [5/7]

◆ operator/() [6/7]

◆ operator/() [7/7]

◆ operator=() [1/8]

◆ operator=() [2/8]

◆ operator=() [3/8]

◆ operator=() [4/8]

◆ operator=() [5/8]

◆ operator=() [6/8]

◆ operator=() [7/8]

◆ operator=() [8/8]

◆ operator==() [1/8]

◆ operator==() [2/8]

◆ operator==() [3/8]

◆ operator==() [4/8]

◆ operator==() [5/8]

◆ operator==() [6/8]

◆ operator==() [7/8]

◆ operator==() [8/8]

◆ setBitElement()

◆ setBitWidth()

◆ setByteElement()

◆ setDoubleFloatElement()