Operand Class Reference

#include <Operand.hh>

Inheritance diagram for Operand:

Collaboration diagram for Operand:

Public Types
enum	OperandType {   SINT_WORD , UINT_WORD , FLOAT_WORD , DOUBLE_WORD ,   HALF_FLOAT_WORD , BOOL , RAW_DATA , SLONG_WORD ,   ULONG_WORD }

Public Member Functions
	Operand (bool isInput)
	Operand (bool isInput, int index, OperandType type)
	Operand (const Operand &op)
virtual	~Operand ()
virtual int	index () const
virtual bool	isInput () const
virtual bool	isOutput () const
virtual OperandType	type () const
virtual void	setType (OperandType type)
virtual const std::string &	typeString () const
virtual TCEString	CTypeString () const
virtual bool	isVector () const
virtual int	elementWidth () const
virtual void	setElementWidth (int elementWidth)
virtual int	elementCount () const
virtual void	setElementCount (int elementCount)
virtual int	width () const
virtual bool	isAddress () const
virtual int	memoryUnits () const
virtual bool	isMemoryData () const
virtual bool	canSwap (const Operand &op) const
virtual const std::set< int > &	swap () const
virtual void	loadState (const ObjectState *state)
virtual ObjectState *	saveState () const
virtual bool	isNull () const
Public Member Functions inherited from Serializable
virtual	~Serializable ()

Static Public Member Functions
static int	defaultElementWidth (OperandType type)

Static Public Attributes
static const std::string	SLONG_WORD_STRING = "SLongWord"
static const std::string	ULONG_WORD_STRING = "ULongWord"
static const std::string	SINT_WORD_STRING = "SIntWord"
static const std::string	UINT_WORD_STRING = "UIntWord"
static const std::string	HALF_FLOAT_WORD_STRING = "HalfFloatWord"
static const std::string	FLOAT_WORD_STRING = "FloatWord"
static const std::string	DOUBLE_WORD_STRING = "DoubleWord"
static const std::string	BOOL_STRING = "Bool"
static const std::string	RAW_DATA_STRING = "RawData"
static const std::string	UNKNOWN_TYPE_STRING = "InvalidValue"
static const std::string	OPRND_ID = "id"
	Object state name for operand id.
static const std::string	OPRND_TYPE = "type"
	Object state name for operand type.
static const std::string	OPRND_MEM_ADDRESS = "mem-address"
	Object state name for memory address.
static const std::string	OPRND_MEM_UNITS = "mem-units"
	Object state name for memory unit count.
static const std::string	OPRND_MEM_DATA = "mem-data"
	Object state name for memory data.
static const std::string	OPRND_CAN_SWAP = "can-swap"
	Object state name for can swap.
static const std::string	OPRND_IN = "in"
	Object state name for input operand.
static const std::string	OPRND_OUT = "out"
	Object state name for output operand.
static const std::string	OPRND_ELEM_WIDTH = "element-width"
	Object state name for element width.
static const std::string	OPRND_ELEM_COUNT = "element-count"
	Object state name for element count.

Private Member Functions
void	clear ()
Operand &	operator= (const Operand &)
	Assignment not allowed.

Private Attributes
int	index_
	Index of the Operand.
bool	isInput_
	Direction of operand.
OperandType	type_
	Type of the Operand.
int	elementWidth_
	Width of an element.
int	elementCount_
	Number of total elements.
bool	isAddress_
	Flag indicating whether Operand is address or not.
int	addressUnits_
	size of the data this operation addresses. 0 if unknown.
bool	isMemoryData_
	Flag indicating whether Operand is memory data or not.
std::set< int >	swap_
	Indexes of Operands which can be swapped with this Operand.

Detailed Description

Class that models Operation Operand.

Contains the static properties of Operation inputs and outputs.

Definition at line 52 of file Operand.hh.

Member Enumeration Documentation

OperandType

enum Operand::OperandType

Type of operand.

Enumerator
SINT_WORD
UINT_WORD
FLOAT_WORD
DOUBLE_WORD
HALF_FLOAT_WORD
BOOL
RAW_DATA
SLONG_WORD
ULONG_WORD

Definition at line 58 of file Operand.hh.

                     {
        SINT_WORD,
        UINT_WORD,
        FLOAT_WORD,
        DOUBLE_WORD,
        HALF_FLOAT_WORD,
        BOOL,
        RAW_DATA,
        SLONG_WORD,
        ULONG_WORD
    };

Constructor & Destructor Documentation

Operand() [1/3]

Operand::Operand ( bool  isInput )

explicit

Default constructor.

Definition at line 75 of file Operand.cc.

                             : 
    Serializable(), index_(0), isInput_(isInput), type_(SINT_WORD), 
    elementCount_(1), isAddress_(false), addressUnits_(0), 
    isMemoryData_(false) {
    elementWidth_ = defaultElementWidth(type_);
}

References defaultElementWidth(), elementWidth_, and type_.

Here is the call graph for this function:

Operand() [2/3]

Operand::Operand ( bool  isInput, int  index, OperandType  type  )

explicit

Constructor.

Parameters

index

Index of operand.

Definition at line 87 of file Operand.cc.

                                                          : 
    Serializable(), index_(index), isInput_(isInput), type_(type),
    elementCount_(1), isAddress_(false), addressUnits_(0), 
    isMemoryData_(false) {
    elementWidth_ = defaultElementWidth(type_);
}

References defaultElementWidth(), elementWidth_, and type_.

Here is the call graph for this function:

Operand() [3/3]

Operand::Operand

(

const Operand &

op

)

Copy constructor.

Parameters

op	Operand to be copied.

Definition at line 99 of file Operand.cc.

                                  : 
    Serializable(), index_(op.index()), isInput_(op.isInput()),
    type_(op.type()), elementWidth_(op.elementWidth()), 
    elementCount_(op.elementCount()), isAddress_(op.isAddress()), 
    addressUnits_(op.addressUnits_), isMemoryData_(op.isMemoryData()),
    swap_(op.swap()) {
}

~Operand()

Operand::~Operand ( )

virtual

Destructor.

Definition at line 110 of file Operand.cc.

                  {
}

Member Function Documentation

canSwap()

bool Operand::canSwap ( const Operand &  op ) const

virtual

Returns true if Operand can be swapped with op.

Parameters

op	Operand being investigated.

Returns

True if Operand can be swapped with op, false otherwise.

Reimplemented in NullOperand.

Definition at line 372 of file Operand.cc.

                                        {
    return ContainerTools::containsValue(swap_, op.index());
}

References ContainerTools::containsValue(), index(), and swap_.

Referenced by OperationPimpl::canSwap(), loadState(), and saveState().

Here is the call graph for this function:

clear()

void Operand::clear ( )

private

Clears the operand.

This is used when operand state is reloaded from ObjectState tree. Old must be cleared first.

Definition at line 120 of file Operand.cc.

               {
    index_ = 0;
    elementWidth_ = 0;
    elementCount_ = 0;
    isAddress_ = false;
    isMemoryData_ = false;
    swap_.clear();
}

References elementCount_, elementWidth_, index_, isAddress_, isMemoryData_, and swap_.

Referenced by loadState().

CTypeString()

TCEString Operand::CTypeString ( ) const

virtual

Definition at line 222 of file Operand.cc.

                           {
    if (isVector()) {
        return "";
    }
    TCEString type;
    switch (this->type()) {
    case Operand::SINT_WORD:
        type = "signed";
        break;
    case Operand::UINT_WORD:
        type = "unsigned";
        break;
    case Operand::FLOAT_WORD:
        return "float";
        break;
    case Operand::DOUBLE_WORD:
        return "double";
        break;
    case Operand::RAW_DATA:
        return "";
        break;
    default:
    // TODO: how do halffloats work?
    // they should not need any casts.
    // cannot return half as it's only supported in opencl.
        return "";
    }
    if (elementWidth() <= 8) {
        return type + " char";
    }
    if (elementWidth() <= 16) {
        return type + " short";
    }
    if (elementWidth() == 64) {
        return type + " long";
    }
    return type + " int";
}

References DOUBLE_WORD, elementWidth(), FLOAT_WORD, isVector(), RAW_DATA, SINT_WORD, type(), and UINT_WORD.

Here is the call graph for this function:

defaultElementWidth()

int Operand::defaultElementWidth ( OperandType  type )

static

Returns default element width depending on operand's type.

Parameters

type	Operand type.

Returns

Element bit width of the operand.

Definition at line 557 of file Operand.cc.

                                             {
    if (type == DOUBLE_WORD || type == SLONG_WORD || type == ULONG_WORD) {
        return 64;
    } else if (type == HALF_FLOAT_WORD) {
        return 16;
    } else if (type == BOOL) {
        return 1;
    } else {
        return 32;
    }
}

References BOOL, DOUBLE_WORD, HALF_FLOAT_WORD, SLONG_WORD, type(), and ULONG_WORD.

Referenced by loadState(), InputOperandDialog::onType(), OutputOperandDialog::onType(), Operand(), and Operand().

Here is the call graph for this function:

elementCount()

int Operand::elementCount ( ) const

virtual

Returns total number of elements.

Returns

Number of elements.

Definition at line 298 of file Operand.cc.

                            {
    return elementCount_;
}

References elementCount_.

Referenced by setElementCount(), and TDGenerator::ValueType::valueTypeStr().

elementWidth()

int Operand::elementWidth ( ) const

virtual

Returns width of an operand element in bits.

Returns

Bit width of an element.

Definition at line 278 of file Operand.cc.

                            {
    return elementWidth_;
}

References elementWidth_.

Referenced by TDGen::analyzeMachineVectorRegisterClasses(), CTypeString(), TDGen::operandChar(), setElementWidth(), TDGen::subwordWidthOfRawData(), and TDGenerator::ValueType::valueTypeStr().

index()

int Operand::index ( ) const

virtual

Returns the index of the Operand.

Returns

The index of the Operand.

Reimplemented in NullOperand.

Definition at line 135 of file Operand.cc.

                     {
    return index_;
}

References index_.

Referenced by canSwap(), TDGen::constantNodeString(), OpsetDialog::createOperation(), TDGen::createTrivialDAG(), TDGen::dagNodeToString(), OperationPimpl::insertOperand(), ImmInfo::key(), OperationPimpl::loadState(), OutputOperandDialog::onOk(), and TDGen::operandToString().

isAddress()

bool Operand::isAddress ( ) const

virtual

Returns true if Operand is address.

Returns

True if Operand is address, false otherwise.

Reimplemented in NullOperand.

Definition at line 328 of file Operand.cc.

                         {
    return isAddress_;
}

References isAddress_.

Referenced by MemoryAliasAnalyzer::addressOperandMove(), TDGen::areImmediateOperandsLegal(), OpsetDialog::createOperation(), llvm::LLVMTCEBuilder::emitInstruction(), llvm::LLVMTCEBuilder::emitOperationMacro(), MemoryAliasAnalyzer::findTwoPartAddressOperands(), llvm::LLVMTCEBuilder::hasAmbiguousASpaceRefs(), MemoryAliasAnalyzer::mausOfOperation(), TDGen::operandToString(), OSEdInfoView::operationPropertyView(), osalInputIndex(), and TDGen::patInputs().

isInput()

bool Operand::isInput ( ) const

virtual

Returns true if operand is input.

Returns

True if operand is input.

Reimplemented in NullOperand.

Definition at line 145 of file Operand.cc.

                       {
    return isInput_;
}

References isInput_.

Referenced by OperationDAGBuilder::connectOperandToNode(), TDGen::constantNodeString(), OpsetDialog::createOperation(), TDGen::createTrivialDAG(), TDGen::dagNodeToString(), SocketBusConnCmd::Do(), llvm::LLVMTCEBuilder::emitInstruction(), ConstantTransformer::runOnMachineFunction(), FUGen::scheduleOperations(), and writeCustomOpMacro().

isMemoryData()

bool Operand::isMemoryData ( ) const

virtual

Returns true if Operand is memory data.

Returns

True if Operand is memory data, false otherwise.

Reimplemented in NullOperand.

Definition at line 351 of file Operand.cc.

                            {
    return isMemoryData_;
}

References isMemoryData_.

Referenced by OSEdInfoView::operationPropertyView().

isNull()

virtual bool Operand::isNull ( ) const

inlinevirtual

Reimplemented in NullOperand.

Definition at line 130 of file Operand.hh.

{ return false; }

Referenced by llvm::LLVMTCEBuilder::emitInstruction(), and ConstantTransformer::runOnMachineFunction().

isOutput()

bool Operand::isOutput ( ) const

virtual

Returns true if operand is output.

Returns

True if operand is output.

Reimplemented in NullOperand.

Definition at line 155 of file Operand.cc.

                        {
    return !isInput_;
}

References isInput_.

Referenced by OperationDAGBuilder::connectOperandToNode(), OpsetDialog::createOperation(), TDGen::dagNodeToString(), llvm::LLVMTCEBuilder::emitInstruction(), and TDGen::patOutputs().

isVector()

bool Operand::isVector ( ) const

virtual

Tells if the operand is a vector operand, in other words, has subwords.

Returns

True, if the operand is a vector operand.

Definition at line 268 of file Operand.cc.

                        {
    return (elementCount_ > 1);
}

References elementCount_.

Referenced by TDGen::analyzeMachineVectorRegisterClasses(), CTypeString(), TDGen::hasRawOperands(), TDGen::hasRegisterClassSupport(), TDGen::operandChar(), TDGen::operandToString(), TDGen::subwordWidthOfRawData(), and writeCustomOpMacro().

loadState()

void Operand::loadState ( const ObjectState *  state )

virtual

Loads Operand state from an ObjectState object.

Parameters

state

State containing operand properties.

Exceptions

ObjectStateLoadingException

If loading fails for some reason.

Implements Serializable.

Definition at line 383 of file Operand.cc.

                                           {
    clear();
 
    string method = "Operand::loadState()";
    
    try {
        index_ = state->intAttribute(OPRND_ID);        
        std::string typeString = state->stringAttribute(OPRND_TYPE);
            
        if (typeString.compare(SINT_WORD_STRING) == 0) {
            type_ = SINT_WORD;
        } else if (typeString.compare(UINT_WORD_STRING) == 0) {
            type_ = UINT_WORD;
        } else if (typeString.compare(SLONG_WORD_STRING) == 0) {
            type_ = SLONG_WORD;
        } else if (typeString.compare(ULONG_WORD_STRING) == 0) {
            type_ = ULONG_WORD;
        } else if (typeString.compare(FLOAT_WORD_STRING) == 0) {
            type_ = FLOAT_WORD;
        } else if (typeString.compare(DOUBLE_WORD_STRING) == 0) {
            type_ = DOUBLE_WORD;
        } else if (typeString.compare(HALF_FLOAT_WORD_STRING) == 0) {
            type_ = HALF_FLOAT_WORD;
        } else if (typeString.compare(BOOL_STRING) == 0) {
            type_ = BOOL;
        } else if (typeString.compare(RAW_DATA_STRING) == 0) {
            type_ = RAW_DATA;
        } else {
            string msg = "Invalid operand type: \"" + typeString + "\""; 
            throw Exception(__FILE__, __LINE__, method, msg);
        }
 
        if (state->hasAttribute(OPRND_ELEM_WIDTH)) {
            elementWidth_ = state->intAttribute(OPRND_ELEM_WIDTH);
        } else {
            elementWidth_ = defaultElementWidth(type_);
        }
 
        if (state->hasAttribute(OPRND_ELEM_COUNT)) {
            elementCount_ = state->intAttribute(OPRND_ELEM_COUNT);
        } else {
            elementCount_ = 1;
        }
    
        isAddress_ = state->boolAttribute(OPRND_MEM_ADDRESS);
        isMemoryData_ = state->boolAttribute(OPRND_MEM_DATA);
 
        if (state->hasAttribute(OPRND_MEM_UNITS)) {
            addressUnits_ = state->intAttribute(OPRND_MEM_UNITS);
        }
 
        if (state->childCount() > 1) {
            string msg = "Erronous number of children";
            throw Exception(__FILE__, __LINE__, method, msg);
        }
     
        for (int j = 0; j < state->childCount(); j++) {
            ObjectState* child = state->child(j);
            if (child->name() == OPRND_CAN_SWAP) {
                for (int i = 0; i < child->childCount(); i++) {
                    ObjectState* canSwap = child->child(i);
                    int id = 
                        Conversion::toInt(canSwap->stringAttribute(OPRND_ID));
                    swap_.insert(id);
                }
            } else {
                string msg = "Unknown attribute: " + child->name();
                throw Exception(__FILE__, __LINE__, method, msg);
            }
        }
        
    } catch (const NumberFormatException& n) {
        string message = "Conversion failed: " + n.errorMessage();
        throw ObjectStateLoadingException(
            __FILE__, __LINE__, method, message);
 
    } catch (const KeyNotFound& k) {
        string message = "Attribute not found: " + k.errorMessage();
        ObjectStateLoadingException error(
            __FILE__, __LINE__, method, message);
        error.setCause(k);
        throw error;
    } catch (Exception& e) {
        string message = 
            "Error while loading operation operand settings. "
            "An error in the operation format?" + e.errorMessageStack();
        ObjectStateLoadingException newe(
            __FILE__, __LINE__, __func__, message);
        newe.setCause(e);
        throw newe;
    }
    catch (...) {
        string message = 
            "Error while loading operation operand settings. "
            "An error in the operation format?";
        ObjectStateLoadingException newe(
            __FILE__, __LINE__, __func__, message);
        throw newe;
    }
}

References __func__, addressUnits_, BOOL, BOOL_STRING, ObjectState::boolAttribute(), canSwap(), ObjectState::child(), ObjectState::childCount(), clear(), defaultElementWidth(), DOUBLE_WORD, DOUBLE_WORD_STRING, elementCount_, elementWidth_, Exception::errorMessage(), Exception::errorMessageStack(), FLOAT_WORD, FLOAT_WORD_STRING, HALF_FLOAT_WORD, HALF_FLOAT_WORD_STRING, ObjectState::hasAttribute(), index_, ObjectState::intAttribute(), isAddress_, isMemoryData_, ObjectState::name(), OPRND_CAN_SWAP, OPRND_ELEM_COUNT, OPRND_ELEM_WIDTH, OPRND_ID, OPRND_MEM_ADDRESS, OPRND_MEM_DATA, OPRND_MEM_UNITS, OPRND_TYPE, RAW_DATA, RAW_DATA_STRING, Exception::setCause(), SINT_WORD, SINT_WORD_STRING, SLONG_WORD, SLONG_WORD_STRING, ObjectState::stringAttribute(), swap_, Conversion::toInt(), type_, typeString(), UINT_WORD, UINT_WORD_STRING, ULONG_WORD, and ULONG_WORD_STRING.

Referenced by OperationPimpl::loadState(), OutputOperandDialog::onOk(), InputOperandDialog::updateOperand(), and OperationPropertyDialog::updateSwapLists().

Here is the call graph for this function:

memoryUnits()

int Operand::memoryUnits ( ) const

virtual

Returns the count of MAU's which this operand addresses.

returns 0 if the operand is not a memory address, or the size of the memory access int MAU's this operation accesses.

Returns

count of MAUs addressed by this operand.

Definition at line 341 of file Operand.cc.

                           {
    return addressUnits_;
}

References addressUnits_.

Referenced by MemoryAliasAnalyzer::mausOfOperation().

operator=()

Operand & Operand::operator= ( const Operand &  )

private

Assignment not allowed.

saveState()

ObjectState * Operand::saveState ( ) const

virtual

Saves the state of the Operation to ObjectState object.

Returns

The created ObjectState tree.

Implements Serializable.

Definition at line 490 of file Operand.cc.

                         {
    
    ObjectState* root = new ObjectState("");
    root->setAttribute(OPRND_ID, index_);
    
    switch(type_) {
    case SINT_WORD:
        root->setAttribute(OPRND_TYPE, SINT_WORD_STRING);
        break;
    case UINT_WORD:
        root->setAttribute(OPRND_TYPE, UINT_WORD_STRING);
        break;
    case SLONG_WORD:
        root->setAttribute(OPRND_TYPE, SLONG_WORD_STRING);
        break;
    case ULONG_WORD:
        root->setAttribute(OPRND_TYPE, ULONG_WORD_STRING);
        break;
    case FLOAT_WORD:
        root->setAttribute(OPRND_TYPE, FLOAT_WORD_STRING);
        break;
    case DOUBLE_WORD:
        root->setAttribute(OPRND_TYPE, DOUBLE_WORD_STRING);
        break;
    case HALF_FLOAT_WORD:
        root->setAttribute(OPRND_TYPE, HALF_FLOAT_WORD_STRING);
        break;
    case BOOL:
        root->setAttribute(OPRND_TYPE, BOOL_STRING);
        break;
    case RAW_DATA:
        root->setAttribute(OPRND_TYPE, RAW_DATA_STRING);
        break;
    default:
        root->setAttribute(OPRND_TYPE, UNKNOWN_TYPE_STRING);        
    }
    
    root->setAttribute(OPRND_ELEM_WIDTH, elementWidth_);
    root->setAttribute(OPRND_ELEM_COUNT, elementCount_);
 
    root->setAttribute(OPRND_MEM_ADDRESS, isAddress_);
    root->setAttribute(OPRND_MEM_DATA, isMemoryData_);
    if (addressUnits_ != 0) {
        root->setAttribute(OPRND_MEM_UNITS, addressUnits_);
    }
 
    if (swap_.size() > 0) {
        ObjectState* canSwap = new ObjectState(OPRND_CAN_SWAP);
        set<int>::const_iterator it = swap_.begin();
        while (it != swap_.end()) {
            ObjectState* canSwapChild = new ObjectState(OPRND_IN);
            canSwapChild->setAttribute(OPRND_ID, *it);
            canSwap->addChild(canSwapChild);
            it++;
        }
        root->addChild(canSwap);
    }
    return root;
}

References ObjectState::addChild(), addressUnits_, BOOL, BOOL_STRING, canSwap(), DOUBLE_WORD, DOUBLE_WORD_STRING, elementCount_, elementWidth_, FLOAT_WORD, FLOAT_WORD_STRING, HALF_FLOAT_WORD, HALF_FLOAT_WORD_STRING, index_, isAddress_, isMemoryData_, OPRND_CAN_SWAP, OPRND_ELEM_COUNT, OPRND_ELEM_WIDTH, OPRND_ID, OPRND_IN, OPRND_MEM_ADDRESS, OPRND_MEM_DATA, OPRND_MEM_UNITS, OPRND_TYPE, RAW_DATA, RAW_DATA_STRING, ObjectState::setAttribute(), SINT_WORD, SINT_WORD_STRING, SLONG_WORD, SLONG_WORD_STRING, swap_, type_, UINT_WORD, UINT_WORD_STRING, ULONG_WORD, ULONG_WORD_STRING, and UNKNOWN_TYPE_STRING.

Referenced by OperationPimpl::saveState(), and OperationPropertyDialog::updateSwapLists().

Here is the call graph for this function:

setElementCount()

void Operand::setElementCount ( int  elementCount )

virtual

Sets the number of elements.

Parameters

New	element count.

Definition at line 308 of file Operand.cc.

                                         {
    elementCount_ = elementCount;
}

References elementCount(), and elementCount_.

Referenced by TDGen::writeOperationDefUsingGivenOperandTypes().

Here is the call graph for this function:

setElementWidth()

void Operand::setElementWidth ( int  elementWidth )

virtual

Sets the element bit width.

Parameters

New	element bit width.

Definition at line 288 of file Operand.cc.

                                         {
    elementWidth_ = elementWidth;
}

References elementWidth(), and elementWidth_.

Referenced by TDGen::writeOperationDefUsingGivenOperandTypes().

Here is the call graph for this function:

setType()

void Operand::setType ( OperandType  type )

virtual

Sets the operand type.

Parameters

type	The new type of the operand.

Definition at line 175 of file Operand.cc.

                                 {
    type_ = type;
}

References type(), and type_.

Referenced by TDGen::writeOperationDefUsingGivenOperandTypes().

Here is the call graph for this function:

swap()

const std::set< int > & Operand::swap ( ) const

virtual

Returns the set of operands that can be swapped with this operand.

Returns

The set of operands that can be swapped with this operand.

Reimplemented in NullOperand.

Definition at line 361 of file Operand.cc.

                    {
    return swap_;
}

References swap_.

Referenced by TDGen::areImmediateOperandsLegal(), OSEdInfoView::operationPropertyView(), and TDGen::writeIntegerImmediateDefs().

type()

Operand::OperandType Operand::type ( ) const

virtual

Returns the type of the Operand.

Returns

The type of the Operand.

Definition at line 165 of file Operand.cc.

                    {
    return type_;
}

References type_.

Referenced by TDGen::analyzeMachineVectorRegisterClasses(), CTypeString(), defaultElementWidth(), TDGen::emulatingOpNodeLLVMName(), OperationPimpl::emulationFunctionName(), TDGen::hasRawOperands(), TDGen::operandChar(), TDGen::operandToString(), operandTypeCString(), setType(), TDGen::subwordWidthOfRawData(), PreOptimizer::tryToRemoveEq(), TDGenerator::ValueType::valueTypeStr(), OperationDAGConverter::writeNode(), and TDGen::writeOperationDefs().

typeString()

const std::string & Operand::typeString ( ) const

virtual

Returns the string type of the Operand.

Returns

The string type of the Operand.

Definition at line 185 of file Operand.cc.

                          {
    switch (type_)
    {
        case SINT_WORD:
            return SINT_WORD_STRING;
            break;
        case UINT_WORD:
            return UINT_WORD_STRING;
            break;
        case SLONG_WORD:
            return SLONG_WORD_STRING;
            break;
        case ULONG_WORD:
            return ULONG_WORD_STRING;
            break;
        case FLOAT_WORD:
            return FLOAT_WORD_STRING;
            break;
        case DOUBLE_WORD:
            return DOUBLE_WORD_STRING;
            break;
        case HALF_FLOAT_WORD:
            return HALF_FLOAT_WORD_STRING;
            break;
        case BOOL:
            return BOOL_STRING;
            break;
        case RAW_DATA:
            return RAW_DATA_STRING;
            break;
        default:
            return UNKNOWN_TYPE_STRING;
            break;
    }
}

References BOOL, BOOL_STRING, DOUBLE_WORD, DOUBLE_WORD_STRING, FLOAT_WORD, FLOAT_WORD_STRING, HALF_FLOAT_WORD, HALF_FLOAT_WORD_STRING, RAW_DATA, RAW_DATA_STRING, SINT_WORD, SINT_WORD_STRING, SLONG_WORD, SLONG_WORD_STRING, type_, UINT_WORD, UINT_WORD_STRING, ULONG_WORD, ULONG_WORD_STRING, and UNKNOWN_TYPE_STRING.

Referenced by loadState(), and OSEdInfoView::operationPropertyView().

width()

int Operand::width ( ) const

virtual

Returns width of the operand in bits.

Returns

Bit width of the operand.

Definition at line 318 of file Operand.cc.

                     {
    return elementWidth_ * elementCount_;
}

References elementCount_, and elementWidth_.

Referenced by OpsetDialog::createOperation(), FUGen::DAGNodeOperandWidth(), MachineInfo::findWidestOperand(), OperationSimulator::initializeOutputs(), MachineConnectivityCheck::operandWidth(), ConstantTransformer::runOnMachineFunction(), FUGen::scheduleOperations(), SimpleOperationExecutor::startOperation(), TDGen::subwordWidthOfRawData(), TDGen::writeScalarOperationExploitations(), and TDGen::writeVectorBitwiseOperationDefs().

Member Data Documentation

addressUnits_

int Operand::addressUnits_

private

size of the data this operation addresses. 0 if unknown.

Definition at line 153 of file Operand.hh.

Referenced by loadState(), memoryUnits(), and saveState().

BOOL_STRING

const std::string Operand::BOOL_STRING = "Bool"

static

Definition at line 77 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

DOUBLE_WORD_STRING

const std::string Operand::DOUBLE_WORD_STRING = "DoubleWord"

static

Definition at line 76 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

elementCount_

int Operand::elementCount_

private

Number of total elements.

Definition at line 149 of file Operand.hh.

Referenced by clear(), elementCount(), isVector(), loadState(), saveState(), setElementCount(), and width().

elementWidth_

int Operand::elementWidth_

private

Width of an element.

Definition at line 147 of file Operand.hh.

Referenced by clear(), elementWidth(), loadState(), Operand(), Operand(), saveState(), setElementWidth(), and width().

FLOAT_WORD_STRING

const std::string Operand::FLOAT_WORD_STRING = "FloatWord"

static

Definition at line 75 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

HALF_FLOAT_WORD_STRING

const std::string Operand::HALF_FLOAT_WORD_STRING = "HalfFloatWord"

static

Definition at line 74 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

index_

int Operand::index_

private

Index of the Operand.

Definition at line 141 of file Operand.hh.

Referenced by clear(), index(), loadState(), and saveState().

isAddress_

bool Operand::isAddress_

private

Flag indicating whether Operand is address or not.

Definition at line 151 of file Operand.hh.

Referenced by clear(), isAddress(), loadState(), and saveState().

isInput_

bool Operand::isInput_

private

Direction of operand.

Definition at line 143 of file Operand.hh.

Referenced by isInput(), and isOutput().

isMemoryData_

bool Operand::isMemoryData_

private

Flag indicating whether Operand is memory data or not.

Definition at line 155 of file Operand.hh.

Referenced by clear(), isMemoryData(), loadState(), and saveState().

OPRND_CAN_SWAP

const string Operand::OPRND_CAN_SWAP = "can-swap"

static

Object state name for can swap.

Definition at line 92 of file Operand.hh.

Referenced by loadState(), saveState(), OperationSerializer::setOperandProperties(), OperationSerializer::toXMLFormat(), InputOperandDialog::updateOperand(), and OperationPropertyDialog::updateSwapLists().

OPRND_ELEM_COUNT

const string Operand::OPRND_ELEM_COUNT = "element-count"

static

Object state name for element count.

Definition at line 100 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), saveState(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

OPRND_ELEM_WIDTH

const string Operand::OPRND_ELEM_WIDTH = "element-width"

static

Object state name for element width.

Definition at line 98 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), saveState(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

OPRND_ID

const string Operand::OPRND_ID = "id"

static

Object state name for operand id.

Definition at line 82 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), OperationPropertyDialog::saveOperation(), saveState(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), InputOperandDialog::updateOperand(), and OperationPropertyDialog::updateSwapLists().

OPRND_IN

const string Operand::OPRND_IN = "in"

static

Object state name for input operand.

Definition at line 94 of file Operand.hh.

Referenced by saveState(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

OPRND_MEM_ADDRESS

const string Operand::OPRND_MEM_ADDRESS = "mem-address"

static

Object state name for memory address.

Definition at line 86 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), saveState(), OperationSerializer::setOperandProperties(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

OPRND_MEM_DATA

const string Operand::OPRND_MEM_DATA = "mem-data"

static

Object state name for memory data.

Definition at line 90 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), saveState(), OperationSerializer::setOperandProperties(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

OPRND_MEM_UNITS

const string Operand::OPRND_MEM_UNITS = "mem-units"

static

Object state name for memory unit count.

Definition at line 88 of file Operand.hh.

Referenced by loadState(), saveState(), OperationSerializer::setOperandProperties(), and OperationSerializer::toXMLFormat().

OPRND_OUT

const string Operand::OPRND_OUT = "out"

static

Object state name for output operand.

Definition at line 96 of file Operand.hh.

OPRND_TYPE

const string Operand::OPRND_TYPE = "type"

static

Object state name for operand type.

Definition at line 84 of file Operand.hh.

Referenced by loadState(), OutputOperandDialog::onOk(), OperationPropertyDialog::saveOperation(), saveState(), OperationSerializer::toOperation(), OperationSerializer::toXMLFormat(), and InputOperandDialog::updateOperand().

RAW_DATA_STRING

const std::string Operand::RAW_DATA_STRING = "RawData"

static

Definition at line 78 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

SINT_WORD_STRING

const std::string Operand::SINT_WORD_STRING = "SIntWord"

static

Definition at line 72 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

SLONG_WORD_STRING

const std::string Operand::SLONG_WORD_STRING = "SLongWord"

static

Definition at line 70 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

swap_

std::set<int> Operand::swap_

private

Indexes of Operands which can be swapped with this Operand.

Definition at line 157 of file Operand.hh.

Referenced by canSwap(), clear(), loadState(), saveState(), and swap().

type_

OperandType Operand::type_

private

Type of the Operand.

Definition at line 145 of file Operand.hh.

Referenced by loadState(), Operand(), Operand(), saveState(), setType(), type(), and typeString().

UINT_WORD_STRING

const std::string Operand::UINT_WORD_STRING = "UIntWord"

static

Definition at line 73 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

ULONG_WORD_STRING

const std::string Operand::ULONG_WORD_STRING = "ULongWord"

static

Definition at line 71 of file Operand.hh.

Referenced by InputOperandDialog::InputOperandDialog(), loadState(), OutputOperandDialog::onOk(), OutputOperandDialog::OutputOperandDialog(), saveState(), typeString(), and InputOperandDialog::updateOperand().

UNKNOWN_TYPE_STRING

const std::string Operand::UNKNOWN_TYPE_STRING = "InvalidValue"

static

Definition at line 79 of file Operand.hh.

Referenced by saveState(), and typeString().

---

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

• Operand.hh
• Operand.cc