ImmediateElement.icc

Go to the documentation of this file.

/*
    Copyright (c) 2002-2009 Tampere University.
 
    This file is part of TTA-Based Codesign Environment (TCE).
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
 */
/**
 * @file ImmediateElement.icc
 *
 * Inline definitions of ImmediateElement class.
 *
 * @author Jussi Nykänen 2003 (nykanen-no.spam-cs.tut.fi)
 * @author Mikael Lepistö 18.12.2003 (tmlepist-no.spam-cs.tut.fi)
 * @note reviewed 21 October 2003 by rl, ml, jn, pj
 *
 * @note rating: yellow
 */
 
#include "Conversion.hh"
 
namespace TPEF {
 
/**
 * Returns true if immediate is inline encoded.
 *
 * @return True immediate is inline encoded.
 */
inline bool
ImmediateElement::isInline() const {
    return (destinationUnit_ == 0);
}
 
/**
 * Adds byte to the immediate.
 *
 * @param aByte Byte stored to immediate.
 */
inline void
ImmediateElement::addByte(Byte aByte) {
    value_.push_back(aByte);
}
 
/**
 * Sets value of one byte of element.
 *
 * @param index Index of byte to set.
 * @param aValue Value to set.
 * @exception OutOfRange Thrown if index is too big.
 */
inline void
ImmediateElement::setByte(unsigned int index, Byte aValue) {
    if (index >= length()) {
        throw OutOfRange(__FILE__, __LINE__, "ImmediateElement::setByte()");
    }
    value_[index] = aValue;
}
 
/**
 * Returns value of one byte in immediate.
 *
 * @param index Index of byte to get.
 * @return Value of immediate.
 * @exception OutOfRange If index is out of bounds.
 */
inline Byte
ImmediateElement::byte(unsigned int index) const {
    if (index >= length()) {
        throw OutOfRange(__FILE__, __LINE__, "ImmediateElement::byte()");
    }
    return value_[index];
}
 
/**
 * Sets value of one word to immediate element.
 *
 * Clears old value and writes a word to element.
 *
 * If immediate is longer that written value, more significant bytes
 * will be zeroed. See setWord(index, aValue) if you want to set
 * word to any position of immediate without modifying other bytes
 * stored inside.
 *
 * @param aValue Value to set.
 */
inline void
ImmediateElement::setWord(Word aValue) {
 
    // remove old value
    value_.clear();
 
    // check how many bytes are needed
    Word tempValue = aValue;
 
    for (unsigned int i = 0; i < sizeof(aValue); i++) {
        if (tempValue > 0) {
            addByte(0);
        }
        tempValue = tempValue >> BYTE_BITWIDTH;
    }
 
    for (unsigned int i = 1; i <= length(); i++) {
        setByte(length() - i, static_cast<Byte>(aValue));
        aValue = aValue >> BYTE_BITWIDTH;
    }
}
 
/**
 * Sets value of long word to immediate element.
 *
 * Clears old value and writes a word to element.
 *
 * If immediate is longer that written value, more significant bytes
 * will be zeroed. See setWord(index, aValue) if you want to set
 * word to any position of immediate without modifying other bytes
 * stored inside.
 *
 * @param aValue Value to set.
 */
inline void
ImmediateElement::setULongWord(LongWord aValue) {
 
    // remove old value
    value_.clear();
 
    // check how many bytes are needed
    LongWord tempValue = aValue;
 
    for (unsigned int i = 0; i < sizeof(aValue); i++) {
        if (tempValue > 0) {
            addByte(0);
        }
        tempValue = tempValue >> BYTE_BITWIDTH;
    }
 
    for (unsigned int i = 1; i <= length(); i++) {
        setByte(length() - i, static_cast<Byte>(aValue));
        aValue = aValue >> BYTE_BITWIDTH;
    }
}
 
/**
 * Sets value of one word to immediate element.
 *
 * Clears old value and writes a signed word to element.
 *
 * If immediate is longer that written value, more significant bytes
 * will be zeroed. See setWord(index, aValue) if you want to set
 * word to any position of immediate without modifying other bytes
 * stored inside.
 *
 * @param aValue Value to set.
 */
inline void
ImmediateElement::setSignedWord(SignedWord sValue) {
 
    Word aValue = sValue;
    // remove old value
    value_.clear();
 
    // check how many bytes are needed
    Word tempValue = aValue;
 
    bool negative = sValue < 0;
    int neededBytes = 1;
    for (unsigned int i = sizeof(aValue) ; i > 1; i--) {
        int upBits = tempValue >> 24;
        if ((negative && upBits != 255) ||
            (!negative && upBits != 0)) {
            neededBytes = i;
            break;
        } else {
            tempValue <<= BYTE_BITWIDTH;
        }
 
    }
 
    for (int i = 0; i < neededBytes; i++) {
        addByte(0);
    }
 
    for (unsigned int i = 1; i <= length(); i++) {
        setByte(length() - i, static_cast<Byte>(aValue));
        aValue = aValue >> BYTE_BITWIDTH;
    }
 
    // if we have a negative sub-sized number but upper bit not set 1
    // add a byte full of sign-bit ones.
    if (negative && length() < 4 && (!((byte(0) & 128) == 128))) {
        value_.insert(value_.begin(), 255); // big endian crap
    }
    // if we have a positive sub-sized number but upper bit is set 1,
    // add a byte full of zeroes.
    if (!negative && length() < 4 && (((byte(0) & 128) == 128))) {
        value_.insert(value_.begin(), 0); // big endian crap
    }
}
 
 
/**
 * Sets value of one word to immediate element.
 *
 * Clears old value and writes a signed word to element.
 *
 * If immediate is longer that written value, more significant bytes
 * will be zeroed. See setWord(index, aValue) if you want to set
 * word to any position of immediate without modifying other bytes
 * stored inside.
 *
 * @param aValue Value to set.
 */
inline void
ImmediateElement::setSignedLong(SLongWord sValue) {
 
    LongWord aValue = sValue;
    // remove old value
    value_.clear();
 
    // check how many bytes are needed
    LongWord tempValue = aValue;
 
    bool negative = sValue < 0;
    int neededBytes = 1;
    for (unsigned int i = sizeof(aValue) ; i > 1; i--) {
        int upBits = tempValue >> 56;
        if ((negative && upBits != 255) ||
            (!negative && upBits != 0)) {
            neededBytes = i;
            break;
        } else {
            tempValue <<= BYTE_BITWIDTH;
        }
 
    }
 
    for (int i = 0; i < neededBytes; i++) {
        addByte(0);
    }
 
    for (unsigned int i = 1; i <= length(); i++) {
        setByte(length() - i, static_cast<Byte>(aValue));
        aValue = aValue >> BYTE_BITWIDTH;
    }
 
    // if we have a negative sub-sized number but upper bit not set 1
    // add a byte full of sign-bit ones.
    if (negative && length() < 8 && (!((byte(0) & 128) == 128))) {
        value_.insert(value_.begin(), 255); // big endian crap
    }
    // if we have a positive sub-sized number but upper bit is set 1,
    // add a byte full of zeroes.
    if (!negative && length() < 8 && (((byte(0) & 128) == 128))) {
        value_.insert(value_.begin(), 0); // big endian crap
    }
}
 
 
 
/**
 * Returns value of element as a word.
 *
 * If you want to get word from given index of immediate see
 * word(index). Empty immediates are read as zero value.
 *
 * @return Value of immediate.
 * @exception OutOfRange Value is too big to return as a word.
 */
inline Word
ImmediateElement::word() const {
    Word retValue = 0;
 
    // convert bytes to word
    for (unsigned int i = 0; i < length(); i++) {
        retValue =
            ((retValue << BYTE_BITWIDTH) |
             static_cast<Byte>(value_[i]));
 
        if (retValue != 0 &&
            length() - i > sizeof(retValue)) {
 
            throw OutOfRange(
                __FILE__, __LINE__, "ImmediateElement::word()",
                "Value to return is longer than value to return.");
        }
    }
 
    return retValue;
}
 
/**
 * Returns value of element as a word.
 *
 * If you want to get word from given index of immediate see
 * word(index). Empty immediates are read as zero value.
 *
 * @return Value of immediate.
 * @exception OutOfRange Value is too big to return as a word.
 */
inline LongWord
ImmediateElement::longWord() const {
 
    LongWord retValue = 0;
 
    // convert bytes to word
    for (unsigned int i = 0; i < length(); i++) {
        retValue =
            ((retValue << BYTE_BITWIDTH) |
             static_cast<Byte>(value_[i]));
 
        if (retValue != 0 &&
            length() - i > sizeof(retValue)) {
 
            throw OutOfRange(
                __FILE__, __LINE__, "ImmediateElement::word()",
                "Value to return is longer than value to return.");
        }
    }
 
    return retValue;
}
 
/**
 * Returns value of element as a signed word.
 *
 * If you want to get word from given index of immediate see
 * word(index). Empty immediates are read as zero value.
 *
 * @return Value of immediate.
 * @exception OutOfRange Value is too big to return as a signed word.
 */
inline SignedWord
ImmediateElement::signedWord() const {
 
    Word retValue = 0;
 
    // convert bytes to word
    for (unsigned int i = 0; i < length(); i++) {
        retValue =
            ((retValue << BYTE_BITWIDTH) |
             static_cast<Byte>(value_[i]));
 
        if (retValue != 0 &&
            length() - i > sizeof(retValue)) {
 
            throw OutOfRange(
                __FILE__, __LINE__, "ImmediateElement::word()",
                "Value to return is longer than value to return.");
        }
    }
 
    // If the most upper bit is true, but length < sizeof(word),
    // this is a signed value, which need to be manually sign-extended.
    unsigned int byteMask = ((1 << BYTE_BITWIDTH)-1);
    if ((retValue >> (BYTE_BITWIDTH * length() -1) & 1) &&
        length() < sizeof(SignedWord)) {
        for (unsigned int i = length(); i < sizeof(SignedWord); i++) {
            retValue |= (byteMask << (BYTE_BITWIDTH*i));
        }
    }
    return static_cast<SignedWord>(retValue);
}
 
/**
 * Returns value of element as a signed word.
 *
 * If you want to get word from given index of immediate see
 * word(index). Empty immediates are read as zero value.
 *
 * @return Value of immediate.
 * @exception OutOfRange Value is too big to return as a signed word.
 */
inline SLongWord
ImmediateElement::sLongWord() const {
 
    SLongWord retValue = 0;
 
    // convert bytes to word
    for (unsigned int i = 0; i < length(); i++) {
        retValue =
            ((retValue << BYTE_BITWIDTH) |
             static_cast<Byte>(value_[i]));
 
        if (retValue != 0 &&
            length() - i > sizeof(retValue)) {
 
            throw OutOfRange(
                __FILE__, __LINE__, "ImmediateElement::word()",
                "Value to return is longer than value to return.");
        }
    }
 
    // If the most upper bit is true, but length < sizeof(word),
    // this is a signed value, which need to be manually sign-extended.
    unsigned long byteMask = ((1 << BYTE_BITWIDTH)-1);
    if ((retValue >> (BYTE_BITWIDTH * length() -1) & 1) &&
        length() < sizeof(SLongWord)) {
        for (unsigned int i = length(); i < sizeof(SLongWord); i++) {
            retValue |= (byteMask << (BYTE_BITWIDTH*i));
        }
    }
    return static_cast<SLongWord>(retValue);
}
 
 
/**
 * Returns the number of bytes taken by the immediate value.
 *
 * @return Length of immediate in bytes.
 */
inline unsigned int
ImmediateElement::length() const {
    return value_.size();
}
 
/**
 * Returns destination unit.
 *
 * Unit 0x00 means that immediate is inline encoded. For inline immediates
 * index is unique identifier and source field of move element should match
 * to that. So destinationIndex and destinationUnit should be same that
 * are in move element, which uses ImmediateElement.
 *
 * @return Destination unit.
 */
inline Byte
ImmediateElement::destinationUnit() const {
    return destinationUnit_;
}
 
/**
 * Sets destination unit.
 *
 * See destinationUnit().
 *
 * @param aDestinationUnit Destination identifier.
 */
inline void
ImmediateElement::setDestinationUnit(Byte aDestinationUnit) {
    destinationUnit_ = aDestinationUnit;
}
 
/**
 * Returns destination index.
 *
 * See destinationUnit().
 *
 * @return Destination index.
 */
inline Byte
ImmediateElement::destinationIndex() const {
    return destinationIndex_;
}
 
/**
 * Sets destination index.
 *
 * See destinationUnit().
 *
 * @param aDestinationIndex Destination index.
 */
inline void
ImmediateElement::setDestinationIndex(Byte aDestinationIndex) {
    destinationIndex_ = aDestinationIndex;
}
 
}