ADFSerializer Class Reference

#include <ADFSerializer.hh>

Inheritance diagram for ADFSerializer:

Collaboration diagram for ADFSerializer:

Public Member Functions
	ADFSerializer ()
virtual	~ADFSerializer ()
void	writeState (const ObjectState *machineState)
ObjectState *	readState ()
void	writeMachine (const TTAMachine::Machine &machine)
TTAMachine::Machine *	readMachine ()
Public Member Functions inherited from XMLSerializer
	XMLSerializer ()
virtual	~XMLSerializer ()
void	setSourceFile (const std::string &fileName)
void	setSourceString (const std::string &source)
void	setDestinationFile (const std::string &fileName)
void	setDestinationString (std::string &destination)
void	setSchemaFile (const std::string &fileName)
void	setUseSchema (bool useSchema)
void	setXMLNamespace (std::string nsUri)
Public Member Functions inherited from TCETools::Serializer
virtual	~Serializer ()

Protected Member Functions
	ADFSerializer (const ADFSerializer &)
	Copying forbidden. More...
ADFSerializer &	operator= (const ADFSerializer &)
	Assingment forbidden. More...
Protected Member Functions inherited from XMLSerializer
std::string	sourceFile () const

Static Private Member Functions
static ObjectState *	convertToMDFFormat (const ObjectState *machineState)
static ObjectState *	busToMDF (const ObjectState *busState)
static ObjectState *	socketToMDF (const ObjectState *socketState)
static ObjectState *	bridgeToMDF (const ObjectState *bridgeState)
static ObjectState *	functionUnitToMDF (const ObjectState *fuState)
static ObjectState *	registerFileToMDF (const ObjectState *rfState)
static ObjectState *	immediateUnitToMDF (const ObjectState *iuState, const ObjectState *machineState)
static ObjectState *	addressSpaceToMDF (const ObjectState *asState)
static ObjectState *	controlUnitToMDF (const ObjectState *cuState)
static ObjectState *	immediateSlotToMDF (const ObjectState *isState)
static ObjectState *	convertToMachineFormat (const ObjectState *mdfState)
static ObjectState *	busToMachine (const ObjectState *busState)
static ObjectState *	socketToMachine (const ObjectState *socketState)
static ObjectState *	bridgeToMachine (const ObjectState *bridgeState)
static ObjectState *	functionUnitToMachine (const ObjectState *fuState, const int orderNumber)
static ObjectState *	registerFileToMachine (const ObjectState *rfState)
static ObjectState *	addressSpaceToMachine (const ObjectState *asState)
static ObjectState *	controlUnitToMachine (const ObjectState *cuState)
static ObjectState *	immediateUnitToMachine (const ObjectState *iuState, ObjectState *machineState)
static ObjectState *	immediateSlotToMachine (const ObjectState *isState)
static ObjectState *	machineSRPort (const ObjectState *mdfSRPortState)
static ObjectState *	mdfSRPort (const ObjectState *machineSRPortState)
static void	setIUExtensionMode (const ObjectState *mdfIUState, ObjectState *momIUState)
static ObjectState *	machineRFPort (const ObjectState *mdfPortState)
static ObjectState *	mdfPort (const ObjectState *machinePortState)
static ObjectState *	machineFUPort (const ObjectState *mdfFUPortState)
static ObjectState *	mdfFUPort (const ObjectState *machineFUPortState)
static ObjectState *	machineOperation (const ObjectState *mdfOperationState)
static ObjectState *	mdfOperation (const ObjectState *machineOperationState)
static ObjectState *	machinePipeline (const ObjectState *mdfPipelineState)
static ObjectState *	mdfPipeline (const ObjectState *machinePipelineState)
static void	instructionTemplateToMDF (const ObjectState *momITState, ObjectState *mdfIUState)
static void	instructionTemplateToMachine (const ObjectState *mdfITState, ObjectState *momMachineState, const std::string &iuName=std::string(""))
static ObjectState *	momTemplateSlot (const ObjectState *momITState, const std::string &busName)
static bool	hasEmptyInstructionTemplate (const ObjectState *momMachineState)

Detailed Description

This class is used to generate a machine object model from MDF file and to generate MDF file from a machine object model.

By default ADFSerializer validates the files it reads with ADF Schema.

Definition at line 49 of file ADFSerializer.hh.

Constructor & Destructor Documentation

ADFSerializer() [1/2]

ADFSerializer::ADFSerializer

(

)

Constructor.

Definition at line 203 of file ADFSerializer.cc.

                             : XMLSerializer() {
    setSchemaFile(Environment::schemaDirPath(ADF_SCHEMA_FILE));
    setUseSchema(true);
}

References ADF_SCHEMA_FILE, Environment::schemaDirPath(), XMLSerializer::setSchemaFile(), and XMLSerializer::setUseSchema().

Here is the call graph for this function:

~ADFSerializer()

ADFSerializer::~ADFSerializer ( )

virtual

Destructor.

Definition at line 212 of file ADFSerializer.cc.

                              {
}

ADFSerializer() [2/2]

ADFSerializer::ADFSerializer ( const ADFSerializer &  )

protected

Copying forbidden.

Member Function Documentation

addressSpaceToMachine()

ObjectState * ADFSerializer::addressSpaceToMachine ( const ObjectState *  asState )

staticprivate

Creates a new ObjectState tree which can be read by AddressSpace::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of address space declaration in MDF file.

Parameters

asState

The ObjectState tree which matches with the syntax of address space declaration in MDF file.

Returns

The newly created ObjectState tree.

Definition at line 1391 of file ADFSerializer.cc.

                                                               {
 
    ObjectState* as = new ObjectState(AddressSpace::OSNAME_ADDRESS_SPACE);
 
    // set name
    as->setAttribute(
        Component::OSKEY_NAME, asState->stringAttribute(AS_NAME));
 
    // set width
    ObjectState* width = asState->childByName(AS_WIDTH);
    as->setAttribute(AddressSpace::OSKEY_WIDTH, width->stringValue());
 
    // set min address
    ObjectState* minAddress = asState->childByName(AS_MIN_ADDRESS);
    as->setAttribute(
        AddressSpace::OSKEY_MIN_ADDRESS, minAddress->stringValue());
 
    // set max address
    ObjectState* maxAddress = asState->childByName(AS_MAX_ADDRESS);
    as->setAttribute(
        AddressSpace::OSKEY_MAX_ADDRESS, maxAddress->stringValue());
 
    if (asState->hasChild(AS_SHARED_MEMORY)) {
        ObjectState* shared = asState->childByName(AS_SHARED_MEMORY);
        as->setAttribute(
            AddressSpace::OSKEY_SHARED_MEMORY, shared->boolValue());
    }
 
    // the numerical ids
    for (int i = 0; i < asState->childCount(); i++) {
        ObjectState* child = asState->child(i);
        if (child->name() == AS_NUMERICAL_ID) {
            ObjectState* idObj = 
                new ObjectState(AddressSpace::OSKEY_NUMERICAL_ID, as);
            idObj->setValue(child->intValue());
            as->addChild(idObj);
        }
    }
    
    return as;
}

References ObjectState::addChild(), AS_MAX_ADDRESS, AS_MIN_ADDRESS, AS_NAME, AS_NUMERICAL_ID, AS_SHARED_MEMORY, AS_WIDTH, ObjectState::boolValue(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), ObjectState::intValue(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

addressSpaceToMDF()

ObjectState * ADFSerializer::addressSpaceToMDF ( const ObjectState *  asState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by AddressSpace::saveState.

Parameters

asState

Root node of the ObjectState tree created by AddressSpace::saveState.

Returns

The newly created ObjectState tree.

Definition at line 852 of file ADFSerializer.cc.

                                                           {
 
    ObjectState* as = new ObjectState(ADDRESS_SPACE);
    as->setAttribute(
        AS_NAME, asState->stringAttribute(AddressSpace::OSKEY_NAME));
 
    // add width element
    ObjectState* width = new ObjectState(AS_WIDTH);
    as->addChild(width);
    width->setValue(asState->stringAttribute(AddressSpace::OSKEY_WIDTH));
 
    // add min-address element
    ObjectState* minAddress = new ObjectState(AS_MIN_ADDRESS);
    as->addChild(minAddress);
    minAddress->setValue(
        asState->stringAttribute(AddressSpace::OSKEY_MIN_ADDRESS));
 
    // add max-address element
    ObjectState* maxAddress = new ObjectState(AS_MAX_ADDRESS);
    as->addChild(maxAddress);
    maxAddress->setValue(
        asState->stringAttribute(AddressSpace::OSKEY_MAX_ADDRESS));
 
    if (asState->hasAttribute(AddressSpace::OSKEY_SHARED_MEMORY)) {
        ObjectState* shared = new ObjectState(AS_SHARED_MEMORY);
        as->addChild(shared);
        shared->setValue(
            asState->boolAttribute(AddressSpace::OSKEY_SHARED_MEMORY));
    }
    // the numerical ids
    for (int i = 0; i < asState->childCount(); i++) {
        ObjectState* child = asState->child(i);
        if (child->name() == AddressSpace::OSKEY_NUMERICAL_ID) {
            ObjectState* idObj = new ObjectState(AS_NUMERICAL_ID, as);
            idObj->setValue(child->intValue());
        }
    }
    return as;
}

References ObjectState::addChild(), ADDRESS_SPACE, AS_MAX_ADDRESS, AS_MIN_ADDRESS, AS_NAME, AS_NUMERICAL_ID, AS_SHARED_MEMORY, AS_WIDTH, ObjectState::boolAttribute(), ObjectState::child(), ObjectState::childCount(), ObjectState::hasAttribute(), ObjectState::intValue(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

bridgeToMachine()

ObjectState * ADFSerializer::bridgeToMachine ( const ObjectState *  bridgeState )

staticprivate

Creates a new ObjectState tree which can be read by Bridge::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of bridge declaration in MDF file.

Parameters

bridgeState

The ObjectState tree which matches with the syntax of bridge declaration in MDF file.

Returns

The newly created ObjectState tree.

Definition at line 1232 of file ADFSerializer.cc.

                                                             {
 
    ObjectState* bridge = new ObjectState(Bridge::OSNAME_BRIDGE);
    bridge->setAttribute(
        Component::OSKEY_NAME, bridgeState->stringAttribute(BRIDGE_NAME));
    ObjectState* readsFrom = bridgeState->childByName(BRIDGE_READS_FROM);
    bridge->setAttribute(Bridge::OSKEY_SOURCE_BUS, readsFrom->stringValue());
    ObjectState* writesTo = bridgeState->childByName(BRIDGE_WRITES_TO);
    bridge->setAttribute(
        Bridge::OSKEY_DESTINATION_BUS, writesTo->stringValue());
    return bridge;
}

References BRIDGE_NAME, BRIDGE_READS_FROM, BRIDGE_WRITES_TO, ObjectState::childByName(), ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

bridgeToMDF()

ObjectState * ADFSerializer::bridgeToMDF ( const ObjectState *  bridgeState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by Bridge::saveState.

Parameters

bridgeState

Root node of the ObjectState tree created by Bridge::saveState.

Returns

The newly created ObjectState tree.

Definition at line 597 of file ADFSerializer.cc.

                                                         {
 
    ObjectState* bridge = new ObjectState(BRIDGE);
    bridge->setAttribute(
        BRIDGE_NAME, bridgeState->stringAttribute(Bridge::OSKEY_NAME));
 
    ObjectState* readsFrom = new ObjectState(BRIDGE_READS_FROM);
    bridge->addChild(readsFrom);
    readsFrom->setValue(
        bridgeState->stringAttribute(Bridge::OSKEY_SOURCE_BUS));
 
    ObjectState* writesTo = new ObjectState(BRIDGE_WRITES_TO);
    bridge->addChild(writesTo);
    writesTo->setValue(
        bridgeState->stringAttribute(Bridge::OSKEY_DESTINATION_BUS));
 
    return bridge;
}

References ObjectState::addChild(), BRIDGE, BRIDGE_NAME, BRIDGE_READS_FROM, BRIDGE_WRITES_TO, ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

busToMachine()

ObjectState * ADFSerializer::busToMachine ( const ObjectState *  busState )

staticprivate

Creates a new ObjectState tree which can be read by Bus::loadState and which corresponds with the given ObjectState tree declaring a bus by MDF syntax.

Parameters

busState

The ObjectState tree declaring a bus by MDF syntax.

Returns

The newly created ObjectState tree.

Definition at line 1064 of file ADFSerializer.cc.

                                                       {
 
    ObjectState* bus = new ObjectState(Bus::OSNAME_BUS);
 
    // set name
    bus->setAttribute(
        Component::OSKEY_NAME, busState->stringAttribute(BUS_NAME));
 
    // set width
    ObjectState* width = busState->childByName(BUS_WIDTH);
    bus->setAttribute(Bus::OSKEY_WIDTH, width->stringValue());
 
    // set immediate width and extension
    ObjectState* shortImm = busState->childByName(SHORT_IMMEDIATE);
    ObjectState* shortImmWidth = shortImm->childByName(SHORT_IMM_WIDTH);
    bus->setAttribute(Bus::OSKEY_IMMWIDTH, shortImmWidth->stringValue());
    ObjectState* shortImmExt = shortImm->childByName(SHORT_IMM_EXTENSION);
    string extension = shortImmExt->stringValue();
    if (extension == SIGN_EXTENSION) {
        bus->setAttribute(Bus::OSKEY_EXTENSION, Bus::OSVALUE_SIGN);
    } else if (extension == ZERO_EXTENSION) {
        bus->setAttribute(Bus::OSKEY_EXTENSION, Bus::OSVALUE_ZERO);
    } else {
        string procName = "ADFSerializer::busToMachine";
        string errorMsg = "Unknown extension value in ObjectState.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
 
    // add segments and guards
    for (int i = 0; i < busState->childCount(); i++) {
        ObjectState* child = busState->child(i);
        if (child->name() == SEGMENT) {
            ObjectState* segment = new ObjectState(Segment::OSNAME_SEGMENT);
            bus->addChild(segment);
            segment->setAttribute(
                Segment::OSKEY_NAME, child->stringAttribute(SEGMENT_NAME));
            ObjectState* writesTo = child->childByName(SEGMENT_WRITES_TO);
            string destination = writesTo->stringValue();
            if (destination != "") {
                segment->setAttribute(
                    Segment::OSKEY_DESTINATION, writesTo->stringValue());
            }
        } else if (child->name() == GUARD) {
            ObjectState* guardType = child->child(0);
            if (guardType->name() == ALWAYS_TRUE_GUARD) {
                ObjectState* ucGuard = new ObjectState(
                    UnconditionalGuard::OSNAME_UNCONDITIONAL_GUARD);
                bus->addChild(ucGuard);
                ucGuard->setAttribute(Guard::OSKEY_INVERTED, false);
            } else if (guardType->name() == ALWAYS_FALSE_GUARD) {
                ObjectState* ucGuard = new ObjectState(
                    UnconditionalGuard::OSNAME_UNCONDITIONAL_GUARD);
                bus->addChild(ucGuard);
                ucGuard->setAttribute(Guard::OSKEY_INVERTED, true);
            } else if (guardType->name() == SIMPLE_EXPR ||
                       guardType->name() == INVERTED_EXPR) {
                ObjectState* boolOrUnit = guardType->child(0);
                string objectStateName;
                string unitNameElem;
                string unitNameAttrib;
                string targetNameElem;
                string targetNameAttrib;
                if (boolOrUnit->name() == GUARD_BOOL) {
                    objectStateName = RegisterGuard::OSNAME_REGISTER_GUARD;
                    unitNameElem = GUARD_REGFILE_NAME;
                    unitNameAttrib = RegisterGuard::OSKEY_REGFILE;
                    targetNameElem = GUARD_REGFILE_INDEX;
                    targetNameAttrib = RegisterGuard::OSKEY_INDEX;
                } else if (boolOrUnit->name() == GUARD_UNIT) {
                    objectStateName = PortGuard::OSNAME_PORT_GUARD;
                    unitNameElem = GUARD_UNIT_NAME;
                    unitNameAttrib = PortGuard::OSKEY_FU;
                    targetNameElem = GUARD_UNIT_PORT;
                    targetNameAttrib = PortGuard::OSKEY_PORT;
                } else {
                    string procName = "ADFSerializer::busToMachine";
                    string errorMsg = "Unknown ObjectState name.";
                    Application::writeToErrorLog(
                        __FILE__, __LINE__, procName, errorMsg);
                    Application::abortProgram();
                }
 
                ObjectState* guard = new ObjectState(objectStateName);
                bus->addChild(guard);
                if (guardType->name() == SIMPLE_EXPR) {
                    guard->setAttribute(Guard::OSKEY_INVERTED, false);
                } else {
                    guard->setAttribute(Guard::OSKEY_INVERTED, true);
                }
                ObjectState* unit = boolOrUnit->childByName(unitNameElem);
                guard->setAttribute(unitNameAttrib, unit->stringValue());
                ObjectState* target = boolOrUnit->childByName(
                    targetNameElem);
                guard->setAttribute(targetNameAttrib, target->stringValue());
            }
        }
    }
 
    return bus;
}

References Application::abortProgram(), ObjectState::addChild(), ALWAYS_FALSE_GUARD, ALWAYS_TRUE_GUARD, BUS_NAME, BUS_WIDTH, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), GUARD, GUARD_BOOL, GUARD_REGFILE_INDEX, GUARD_REGFILE_NAME, GUARD_UNIT, GUARD_UNIT_NAME, GUARD_UNIT_PORT, INVERTED_EXPR, ObjectState::name(), SEGMENT, SEGMENT_NAME, SEGMENT_WRITES_TO, ObjectState::setAttribute(), SHORT_IMM_EXTENSION, SHORT_IMM_WIDTH, SHORT_IMMEDIATE, SIGN_EXTENSION, SIMPLE_EXPR, ObjectState::stringAttribute(), ObjectState::stringValue(), Application::writeToErrorLog(), and ZERO_EXTENSION.

Referenced by convertToMachineFormat().

Here is the call graph for this function:

busToMDF()

ObjectState * ADFSerializer::busToMDF ( const ObjectState *  busState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by Bus::saveState.

Parameters

busState

Root node of the ObjectState tree created by Bus::saveState.

Returns

The newly created ObjectState tree.

Definition at line 419 of file ADFSerializer.cc.

                                                   {
 
    ObjectState* root = new ObjectState(BUS);
    root->setAttribute(BUS_NAME, busState->stringAttribute(Bus::OSKEY_NAME));
 
    // add width element
    ObjectState* widthChild = new ObjectState(BUS_WIDTH);
    widthChild->setValue(busState->stringAttribute(Bus::OSKEY_WIDTH));
    root->addChild(widthChild);
 
    // add guards
    for (int i = 0; i < busState->childCount(); i++) {
        ObjectState* child = busState->child(i);
 
        if (child->name() == PortGuard::OSNAME_PORT_GUARD ||
            child->name() == RegisterGuard::OSNAME_REGISTER_GUARD) {
            string guardType;
            string guardUnit;
            string guardTarget;
            string unitNameAttrib;
            string targetNameAttrib;
            if (child->name() == PortGuard::OSNAME_PORT_GUARD) {
                guardType = GUARD_UNIT;
                guardUnit = GUARD_UNIT_NAME;
                guardTarget = GUARD_UNIT_PORT;
                unitNameAttrib = PortGuard::OSKEY_FU;
                targetNameAttrib = PortGuard::OSKEY_PORT;
            } else if (child->name() ==
                       RegisterGuard::OSNAME_REGISTER_GUARD) {
                guardType = GUARD_BOOL;
                guardUnit = GUARD_REGFILE_NAME;
                guardTarget = GUARD_REGFILE_INDEX;
                unitNameAttrib = RegisterGuard::OSKEY_REGFILE;
                targetNameAttrib = RegisterGuard::OSKEY_INDEX;
            }
 
            ObjectState* guardChild = new ObjectState(GUARD);
            root->addChild(guardChild);
            ObjectState* conditionalChild;
            if (child->intAttribute(Guard::OSKEY_INVERTED)) {
                conditionalChild = new ObjectState(INVERTED_EXPR);
            } else {
                conditionalChild = new ObjectState(SIMPLE_EXPR);
            }
            guardChild->addChild(conditionalChild);
            ObjectState* typeChild = new ObjectState(guardType);
            conditionalChild->addChild(typeChild);
            ObjectState* unitChild = new ObjectState(guardUnit);
            typeChild->addChild(unitChild);
            unitChild->setValue(child->stringAttribute(unitNameAttrib));
            ObjectState* targetChild = new ObjectState(guardTarget);
            typeChild->addChild(targetChild);
            targetChild->setValue(child->stringAttribute(targetNameAttrib));
 
        } else if (child->name() ==
                   UnconditionalGuard::OSNAME_UNCONDITIONAL_GUARD) {
 
            // unconditional guards
            ObjectState* guardChild = new ObjectState(GUARD);
            root->addChild(guardChild);
            if (child->boolAttribute(Guard::OSKEY_INVERTED)) {
                guardChild->addChild(new ObjectState(ALWAYS_FALSE_GUARD));
            } else {
                guardChild->addChild(new ObjectState(ALWAYS_TRUE_GUARD));
            }
        }
    }
 
    // add segments
    for (int i = 0; i < busState->childCount(); i++) {
        ObjectState* child = busState->child(i);
 
        if (child->name() == Segment::OSNAME_SEGMENT) {
            ObjectState* segment = new ObjectState(SEGMENT);
            root->addChild(segment);
            segment->setAttribute(
                SEGMENT_NAME, child->stringAttribute(Segment::OSKEY_NAME));
            ObjectState* writesTo = new ObjectState(SEGMENT_WRITES_TO);
            segment->addChild(writesTo);
            if (child->hasAttribute(Segment::OSKEY_DESTINATION)) {
                writesTo->setValue(
                    child->stringAttribute(Segment::OSKEY_DESTINATION));
            }
        }
    }
 
    // add short immediate element
    ObjectState* sImmChild = new ObjectState(SHORT_IMMEDIATE);
    root->addChild(sImmChild);
    ObjectState* extensionChild = new ObjectState(SHORT_IMM_EXTENSION);
    string extension = busState->stringAttribute(Bus::OSKEY_EXTENSION);
    if (extension == Bus::OSVALUE_SIGN) {
        extensionChild->setValue(SIGN_EXTENSION);
    } else if (extension == Bus::OSVALUE_ZERO) {
        extensionChild->setValue(ZERO_EXTENSION);
    } else {
        string procName = "MDFSerialiser::busToMDF";
        string errorMsg = "Unknown extension attribute value in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
 
    sImmChild->addChild(extensionChild);
    ObjectState* sImmWidthChild = new ObjectState(SHORT_IMM_WIDTH);
    sImmChild->addChild(sImmWidthChild);
    sImmWidthChild->setValue(busState->stringAttribute(Bus::OSKEY_IMMWIDTH));
 
   return root;
}

References Application::abortProgram(), ObjectState::addChild(), ALWAYS_FALSE_GUARD, ALWAYS_TRUE_GUARD, ObjectState::boolAttribute(), BUS, BUS_NAME, BUS_WIDTH, ObjectState::child(), ObjectState::childCount(), GUARD, GUARD_BOOL, GUARD_REGFILE_INDEX, GUARD_REGFILE_NAME, GUARD_UNIT, GUARD_UNIT_NAME, GUARD_UNIT_PORT, ObjectState::hasAttribute(), ObjectState::intAttribute(), INVERTED_EXPR, ObjectState::name(), SEGMENT, SEGMENT_NAME, SEGMENT_WRITES_TO, ObjectState::setAttribute(), ObjectState::setValue(), SHORT_IMM_EXTENSION, SHORT_IMM_WIDTH, SHORT_IMMEDIATE, SIGN_EXTENSION, SIMPLE_EXPR, ObjectState::stringAttribute(), Application::writeToErrorLog(), and ZERO_EXTENSION.

Referenced by convertToMDFFormat().

Here is the call graph for this function:

controlUnitToMachine()

ObjectState * ADFSerializer::controlUnitToMachine ( const ObjectState *  cuState )

staticprivate

Creates a new ObjectState tree which can be read by ControlUnit::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of control unit declaration in MDF file.

Parameters

cuState

The ObjectState tree which matches with the syntax of control unit declaration in MDF file.

Returns

The newly created ObjectState tree.

Definition at line 1446 of file ADFSerializer.cc.

                                                              {
 
    ObjectState* cu = new ObjectState(ControlUnit::OSNAME_CONTROL_UNIT);
 
    // set name
    cu->setAttribute(
        Component::OSKEY_NAME, cuState->stringAttribute(CU_NAME));
 
    // set address space
    ObjectState* as = cuState->childByName(CU_ADDRESS_SPACE);
    string asName = as->stringValue();
    if (asName != "") {
        cu->setAttribute(FunctionUnit::OSKEY_AS, as->stringValue());
    }
 
    // set delay slots
    ObjectState* delaySlots = cuState->childByName(CU_DELAY_SLOTS);
    cu->setAttribute(
        ControlUnit::OSKEY_DELAY_SLOTS, delaySlots->stringValue());
 
    // set the guard latency
    ObjectState* gLatency = cuState->childByName(CU_GUARD_LATENCY);
    cu->setAttribute(
        ControlUnit::OSKEY_GUARD_LATENCY, gLatency->stringValue());
    
    // set ports
    for (int i = 0; i < cuState->childCount(); i++) {
        ObjectState* child = cuState->child(i);
        if (child->name() == PORT) {
            cu->addChild(machineFUPort(child));
        } else if (child->name() == CU_SPECIAL_PORT) {
            cu->addChild(machineSRPort(child));
        }
    }
 
    // set return address port binding
    ObjectState* raElem = cuState->childByName(CU_RETURN_ADDRESS);
    string raPortName = raElem->stringValue();
    if (raPortName != "") {
        cu->setAttribute(ControlUnit::OSKEY_RA_PORT, raPortName);
    }
 
    // set operations
    for (int i = 0; i < cuState->childCount(); i++) {
        ObjectState* child = cuState->child(i);
        if (child->name() == CU_CTRL_OPERATION) {
            cu->addChild(machineOperation(child));
        }
    }
 
    return cu;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), CU_ADDRESS_SPACE, CU_CTRL_OPERATION, CU_DELAY_SLOTS, CU_GUARD_LATENCY, CU_NAME, CU_RETURN_ADDRESS, CU_SPECIAL_PORT, machineFUPort(), machineOperation(), machineSRPort(), ObjectState::name(), PORT, ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

controlUnitToMDF()

ObjectState * ADFSerializer::controlUnitToMDF ( const ObjectState *  cuState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by ControlUnit::saveState.

Parameters

cuState

Root node of the ObjectState tree created by ControlUnit::saveState.

Returns

The newly created ObjectState tree.

Definition at line 905 of file ADFSerializer.cc.

                                                          {
 
    ObjectState* cUnit = new ObjectState(CONTROL_UNIT);
    cUnit->setAttribute(
        CU_NAME, cuState->stringAttribute(ControlUnit::OSKEY_NAME));
 
    // add operand ports
    for (int i = 0; i < cuState->childCount(); i++) {
        ObjectState* child = cuState->child(i);
        if (child->name() == FUPort::OSNAME_FUPORT) {
            cUnit->addChild(mdfFUPort(child));
        }
    }
 
    // add special ports
    for (int i = 0; i < cuState->childCount(); i++) {
        ObjectState* child = cuState->child(i);
        if (child->name() == SpecialRegisterPort::OSNAME_SPECIAL_REG_PORT) {
            cUnit->addChild(mdfSRPort(child));
        }
    }
 
    // add return-address element
    ObjectState* raElement = new ObjectState(CU_RETURN_ADDRESS);
    cUnit->addChild(raElement);
    if (cuState->hasAttribute(ControlUnit::OSKEY_RA_PORT)) {
        raElement->setValue(
            cuState->stringAttribute(ControlUnit::OSKEY_RA_PORT));
    }
 
    // add operations
    for (int i = 0; i < cuState->childCount(); i++) {
        ObjectState* child = cuState->child(i);
        if (child->name() == HWOperation::OSNAME_OPERATION) {
            ObjectState* ctrlOperation = mdfOperation(child);
            ctrlOperation->setName(CU_CTRL_OPERATION);
            cUnit->addChild(ctrlOperation);
        }
    }
 
    // add address space element
    ObjectState* as = new ObjectState(CU_ADDRESS_SPACE);
    cUnit->addChild(as);
    if (cuState->hasAttribute(FunctionUnit::OSKEY_AS)) {
        as->setValue(cuState->stringAttribute(FunctionUnit::OSKEY_AS));
    }
 
    // add delay-slots element
    ObjectState* dSlots = new ObjectState(CU_DELAY_SLOTS);
    cUnit->addChild(dSlots);
    dSlots->setValue(
        cuState->stringAttribute(ControlUnit::OSKEY_DELAY_SLOTS));
 
    // add guard latency element
    ObjectState* gLatency = new ObjectState(CU_GUARD_LATENCY);
    cUnit->addChild(gLatency);
    gLatency->setValue(
        cuState->stringAttribute(ControlUnit::OSKEY_GUARD_LATENCY));
 
    return cUnit;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), CONTROL_UNIT, CU_ADDRESS_SPACE, CU_CTRL_OPERATION, CU_DELAY_SLOTS, CU_GUARD_LATENCY, CU_NAME, CU_RETURN_ADDRESS, ObjectState::hasAttribute(), mdfFUPort(), mdfOperation(), mdfSRPort(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::setName(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

convertToMachineFormat()

ObjectState * ADFSerializer::convertToMachineFormat ( const ObjectState *  mdfState )

staticprivate

Creates a new ObjectState tree which can be read by Machine::loadState and which corresponds with the given ObjectState tree.

Parameters

mdfState

An ObjectState tree whose structure matches with MDF file structure.

Returns

The newly created ObjectState tree.

Exceptions

SerializerException

If an error occurs while converting.

Definition at line 995 of file ADFSerializer.cc.

                                                                 {
    ObjectState* machine = new ObjectState(Machine::OSNAME_MACHINE);
    
    // Will count the number of function units and give sequential number
    // to each of them.
    int orderNumber = 0;
    
    try {
        for (int i = 0; i < mdfState->childCount(); i++) {
            ObjectState* child = mdfState->child(i);
        if (child->name() == TRIGGER_INVALIDATES_OLD_RESULTS) {
                machine->setAttribute(
                    Machine::OSKEY_TRIGGER_INVALIDATES_OLD_RESULTS, true);            
            } else if (child->name() == ALWAYS_WRITE_BACK_RESULTS) {
                machine->setAttribute(
                    Machine::OSKEY_ALWAYS_WRITE_BACK_RESULTS, true);
            } else if (child->name() == LITTLE_ENDIAN_MACHINE) {
                machine->setAttribute(LITTLE_ENDIAN_MACHINE, true);
            } else if (child->name() == BITNESS64) {
                machine->setAttribute(BITNESS64, true);
            } else if (child->name() == FUNCTION_UNITS_ORDERED) {
                machine->setAttribute(
                    Machine::OSKEY_FUNCTION_UNITS_ORDERED, true);                
            } else if (child->name() == BUS) {
                machine->addChild(busToMachine(child));
            } else if (child->name() == SOCKET) {
                machine->addChild(socketToMachine(child));
            } else if (child->name() == BRIDGE) {
                machine->addChild(bridgeToMachine(child));
            } else if (child->name() == FUNCTION_UNIT) {
                orderNumber++;
                machine->addChild(functionUnitToMachine(child, orderNumber));
            } else if (child->name() == REGISTER_FILE) {
                machine->addChild(registerFileToMachine(child));
            } else if (child->name() == ADDRESS_SPACE) {
                machine->addChild(addressSpaceToMachine(child));
            } else if (child->name() == CONTROL_UNIT) {
                machine->addChild(controlUnitToMachine(child));
            } else if (child->name() == IMMEDIATE_UNIT) {
                machine->addChild(immediateUnitToMachine(child, machine));
            } else if (child->name() == IMMEDIATE_SLOT) {
                machine->addChild(immediateSlotToMachine(child));
            } else if (child->name() == IU_TEMPLATE) {
                // the instruction template must not belong to any IU in case
                // one defines a template with implicit slots
                instructionTemplateToMachine(child, machine);
            } else if (
                child->name() == OperationTriggeredFormat::OSNAME_FORMAT) {
                ObjectState* newChild = new ObjectState(*child);
                machine->addChild(newChild);
            }
        }
    } catch (const SerializerException&) {
        delete machine;
        throw;
    }
 
    return machine;
}

References ADDRESS_SPACE, addressSpaceToMachine(), ALWAYS_WRITE_BACK_RESULTS, BITNESS64, BRIDGE, bridgeToMachine(), BUS, busToMachine(), ObjectState::child(), ObjectState::childCount(), CONTROL_UNIT, controlUnitToMachine(), FUNCTION_UNIT, FUNCTION_UNITS_ORDERED, functionUnitToMachine(), IMMEDIATE_SLOT, IMMEDIATE_UNIT, immediateSlotToMachine(), immediateUnitToMachine(), instructionTemplateToMachine(), IU_TEMPLATE, LITTLE_ENDIAN_MACHINE, machine, ObjectState::name(), REGISTER_FILE, registerFileToMachine(), SOCKET, socketToMachine(), and TRIGGER_INVALIDATES_OLD_RESULTS.

Referenced by readState().

Here is the call graph for this function:

convertToMDFFormat()

ObjectState * ADFSerializer::convertToMDFFormat ( const ObjectState *  machineState )

staticprivate

Converts the given ObjectState tree created by Machine to correspond with MDF format.

Parameters

machineState

Root of the ObjectState tree.

Returns

The newly created ObjectState tree which matches with MDF format.

Definition at line 292 of file ADFSerializer.cc.

                                                                 {
 
    ObjectState* root = new ObjectState(MDF);
    root->setAttribute(MDF_VERSION, MDF_VERSION_NUMBER);
 
    // Test for global attributes.
    if (machineState->hasAttribute(
        Machine::OSKEY_TRIGGER_INVALIDATES_OLD_RESULTS) &&
        machineState->boolAttribute(
            Machine::OSKEY_TRIGGER_INVALIDATES_OLD_RESULTS)) {
            root->addChild(new ObjectState(TRIGGER_INVALIDATES_OLD_RESULTS));  
    }        
    if (machineState->hasAttribute(Machine::OSKEY_ALWAYS_WRITE_BACK_RESULTS) &&
        machineState->boolAttribute(Machine::OSKEY_ALWAYS_WRITE_BACK_RESULTS)) {                    
        root->addChild(new ObjectState(ALWAYS_WRITE_BACK_RESULTS));              
    }
    if (machineState->hasAttribute(Machine::OSKEY_FUNCTION_UNITS_ORDERED) &&
        machineState->boolAttribute(Machine::OSKEY_FUNCTION_UNITS_ORDERED)) { 
        root->addChild(new ObjectState(FUNCTION_UNITS_ORDERED));              
    }
    if (machineState->hasAttribute(LITTLE_ENDIAN_MACHINE) &&
        machineState->boolAttribute(LITTLE_ENDIAN_MACHINE)) { 
        root->addChild(new ObjectState(LITTLE_ENDIAN_MACHINE));              
    }
 
    if (machineState->hasAttribute(BITNESS64) &&
        machineState->boolAttribute(BITNESS64)) {
        root->addChild(new ObjectState(BITNESS64));
    }
 
    // add buses
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == Bus::OSNAME_BUS) {
            root->addChild(busToMDF(child));
        }
    }
 
    // add sockets
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == Socket::OSNAME_SOCKET) {
            root->addChild(socketToMDF(child));
        }
    }
 
    // add bridges
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == Bridge::OSNAME_BRIDGE) {
            root->addChild(bridgeToMDF(child));
        }
    }
 
    // add function units
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == FunctionUnit::OSNAME_FU) {
            root->addChild(functionUnitToMDF(child));
        }
    }
 
    // add register files
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == RegisterFile::OSNAME_REGISTER_FILE) {
            root->addChild(registerFileToMDF(child));
        }
    }
 
    // add address spaces
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == AddressSpace::OSNAME_ADDRESS_SPACE) {
            root->addChild(addressSpaceToMDF(child));
        }
    }
 
    // add control unit
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == ControlUnit::OSNAME_CONTROL_UNIT) {
            root->addChild(controlUnitToMDF(child));
        }
    }
 
    // add immediate units
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == ImmediateUnit::OSNAME_IMMEDIATE_UNIT) {
            root->addChild(immediateUnitToMDF(child, machineState));
        }
    }
 
    // add immediate slots
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == ImmediateSlot::OSNAME_IMMEDIATE_SLOT) {
            root->addChild(immediateSlotToMDF(child));
        }
    }
 
    // Add operation triggered formats
    for (int i = 0; i < machineState->childCount(); i++) {
        ObjectState* child = machineState->child(i);
        if (child->name() == OperationTriggeredFormat::OSNAME_FORMAT) {
            ObjectState* newChild = new ObjectState(*child);
            root->addChild(newChild);
        }
    }
 
    return root;
}

References ObjectState::addChild(), addressSpaceToMDF(), ALWAYS_WRITE_BACK_RESULTS, BITNESS64, ObjectState::boolAttribute(), bridgeToMDF(), busToMDF(), ObjectState::child(), ObjectState::childCount(), controlUnitToMDF(), FUNCTION_UNITS_ORDERED, functionUnitToMDF(), ObjectState::hasAttribute(), immediateSlotToMDF(), immediateUnitToMDF(), LITTLE_ENDIAN_MACHINE, MDF, MDF_VERSION, MDF_VERSION_NUMBER, ObjectState::name(), registerFileToMDF(), ObjectState::setAttribute(), socketToMDF(), and TRIGGER_INVALIDATES_OLD_RESULTS.

Referenced by writeState().

Here is the call graph for this function:

functionUnitToMachine()

ObjectState * ADFSerializer::functionUnitToMachine ( const ObjectState *  fuState, const int  orderNumber  )

staticprivate

Creates a new ObjectState tree which can be read by FunctionUnit::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of function unit declaration in MDF file.

Parameters

fuState	The ObjectState tree which matches with the syntax of function unit declaration in MDF file.
orderNumber	The number indicating sequential position of the FU in the ADF.

Returns

The newly created ObjectState tree.

Definition at line 1260 of file ADFSerializer.cc.

                           {
 
    ObjectState* fu = new ObjectState(FunctionUnit::OSNAME_FU);
 
    // set name
    fu->setAttribute(
        Component::OSKEY_NAME, fuState->stringAttribute(FU_NAME));
    // each FU has own value of ordering
    fu->setAttribute(FunctionUnit::OSKEY_ORDER_NUMBER, orderNumber);
    // set address space
    ObjectState* as = fuState->childByName(FU_ADDRESS_SPACE);
    string asName = as->stringValue();
    if (asName != "") {
        fu->setAttribute(FunctionUnit::OSKEY_AS, asName);
    }
 
    // set ports and operations
    for (int i = 0; i < fuState->childCount(); i++) {
        ObjectState* child = fuState->child(i);
        if (child->name() == PORT) {
            fu->addChild(machineFUPort(child));
        } else if (child->name() == FU_OPERATION) {
            fu->addChild(machineOperation(child));
        }
    }
 
    return fu;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FU_ADDRESS_SPACE, FU_NAME, FU_OPERATION, machineFUPort(), machineOperation(), ObjectState::name(), PORT, ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

functionUnitToMDF()

ObjectState * ADFSerializer::functionUnitToMDF ( const ObjectState *  fuState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by FunctionUnit::saveState.

Parameters

fuState

Root node of the ObjectState tree created by FunctionUnit::saveState.

Returns

The newly created ObjectState tree.

Definition at line 629 of file ADFSerializer.cc.

                                                           {
 
    ObjectState* fu = new ObjectState(FUNCTION_UNIT);
    fu->setAttribute(
        FU_NAME, fuState->stringAttribute(FunctionUnit::OSKEY_NAME));
 
    // add ports and operations
    for (int i = 0; i < fuState->childCount(); i++) {
        ObjectState* child = fuState->child(i);
        if (child->name() == FUPort::OSNAME_FUPORT) {
            fu->addChild(mdfFUPort(child));
        } else if (child->name() == HWOperation::OSNAME_OPERATION) {
            fu->addChild(mdfOperation(child));
        }
    }
 
    // add address space
    ObjectState* addressSpace = new ObjectState(FU_ADDRESS_SPACE);
    fu->addChild(addressSpace);
 
    // set address space name if it exists
    if (fuState->hasAttribute(FunctionUnit::OSKEY_AS)) {
        addressSpace->setValue(
            fuState->stringAttribute(FunctionUnit::OSKEY_AS));
    }
 
    return fu;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), FU_ADDRESS_SPACE, FU_NAME, FUNCTION_UNIT, ObjectState::hasAttribute(), mdfFUPort(), mdfOperation(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

hasEmptyInstructionTemplate()

bool ADFSerializer::hasEmptyInstructionTemplate ( const ObjectState *  momMachineState )

staticprivate

Checks whether the machine represented by the given ObjectState tree contains an empty instruction template.

Parameters

momMachineState

The ObjectState tree.

Returns

True if it contains an empty instruction template, otherwise false.

Definition at line 2332 of file ADFSerializer.cc.

                                        {
 
    for (int i = 0; i < momMachineState->childCount(); i++) {
        ObjectState* child = momMachineState->child(i);
        if (child->name() ==
            InstructionTemplate::OSNAME_INSTRUCTION_TEMPLATE &&
            child->childCount() == 0) {
            return true;
        }
    }
 
    return false;
}

References ObjectState::child(), ObjectState::childCount(), and ObjectState::name().

Referenced by immediateUnitToMachine().

Here is the call graph for this function:

immediateSlotToMachine()

ObjectState * ADFSerializer::immediateSlotToMachine ( const ObjectState *  isState )

staticprivate

Creates an ObjectState instance that can be loaded by ImmediateSlot instance.

Parameters

isState

An ObjectState instance that represents an immediate-slot element of ADF file.

Returns

The newly created ObjectState instance.

Definition at line 1636 of file ADFSerializer.cc.

                                                                {
    ObjectState* immediateSlot = new ObjectState(
        ImmediateSlot::OSNAME_IMMEDIATE_SLOT);
    immediateSlot->setAttribute(
        ImmediateSlot::OSKEY_NAME, 
        isState->stringAttribute(IMMEDIATE_SLOT_NAME));
    return immediateSlot;
}

References IMMEDIATE_SLOT_NAME, ObjectState::setAttribute(), and ObjectState::stringAttribute().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

immediateSlotToMDF()

ObjectState * ADFSerializer::immediateSlotToMDF ( const ObjectState *  isState )

staticprivate

Creates a new ObjectState instance that matches with the syntax of immediate-slot element in ADF file.

Parameters

isState

ObjectState instance representing ImmediateSlot instance.

Returns

The newly created ObjectState instance.

Definition at line 976 of file ADFSerializer.cc.

                                                            {
    ObjectState* immediateSlot = new ObjectState(IMMEDIATE_SLOT);
    immediateSlot->setAttribute(
        IMMEDIATE_SLOT_NAME, 
        isState->stringAttribute(ImmediateSlot::OSKEY_NAME));
    return immediateSlot;
}

References IMMEDIATE_SLOT, IMMEDIATE_SLOT_NAME, ObjectState::setAttribute(), and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

immediateUnitToMachine()

ObjectState * ADFSerializer::immediateUnitToMachine ( const ObjectState *  iuState, ObjectState *  machineState  )

staticprivate

Creates a new ObjectState tree which can be read by ImmediateUnit::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of immediate unit declaration in MDF file. Adds also instruction template ObjectStates to the given ObjectState tree which contains the whole machine.

Parameters

iuState	The ObjectState tree which matches with the syntax of immediate unit declaration in MDF file.
machineState	The ObjectState tree containing tree instruction templates as child objects.

Returns

The newly created ObjectState tree.

Exceptions

SerializerException

If an error occurs while processing.

Definition at line 1517 of file ADFSerializer.cc.

                                                           {
    ObjectState* iu = new ObjectState(ImmediateUnit::OSNAME_IMMEDIATE_UNIT);
 
    // set name
    iu->setAttribute(
        Component::OSKEY_NAME, iuState->stringAttribute(IU_NAME));
 
    // set type
    ObjectState* typeChild = iuState->childByName(IU_TYPE);
    string type = typeChild->stringValue();
    if (type == IU_TYPE_NORMAL) {
        iu->setAttribute(
            ImmediateUnit::OSKEY_TYPE, ImmediateUnit::OSVALUE_NORMAL);
    } else if (type == IU_TYPE_RESERVED) {
        iu->setAttribute(
            ImmediateUnit::OSKEY_TYPE, ImmediateUnit::OSVALUE_RESERVED);
    } else if (type == IU_TYPE_VOLATILE) {
        iu->setAttribute(
            ImmediateUnit::OSKEY_TYPE, ImmediateUnit::OSVALUE_VOLATILE);
    } else {
        string procName = "ADFSerializer::registerFileToMachine";
        string errorMsg = "Unknown register file type in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
 
    // set size
    ObjectState* size = iuState->childByName(IU_SIZE);
    iu->setAttribute(BaseRegisterFile::OSKEY_SIZE, size->stringValue());
 
    // set width
    ObjectState* width = iuState->childByName(IU_WIDTH);
    iu->setAttribute(BaseRegisterFile::OSKEY_WIDTH, width->stringValue());
 
    // set max reads
    ObjectState* maxReads = iuState->childByName(IU_MAX_READS);
    iu->setAttribute(
        ImmediateUnit::OSKEY_MAX_READS, maxReads->stringValue());
 
    // set max writes
    ObjectState* maxWrites = iuState->childByName(IU_MAX_WRITES);
    iu->setAttribute(
        ImmediateUnit::OSKEY_MAX_WRITES, maxWrites->stringValue());
    
    // set guard latency
    if (iuState->hasChild(IU_GUARD_LATENCY)) {
        ObjectState* guardLatencyChild =
            iuState->childByName(IU_GUARD_LATENCY);
        iu->setAttribute(
            ImmediateUnit::OSKEY_GUARD_LATENCY,
            guardLatencyChild->stringValue());
    } else {
        iu->setAttribute(ImmediateUnit::OSKEY_GUARD_LATENCY, 0);
    }
 
    // set read latency
    if (iuState->hasChild(IU_LATENCY)) {
        ObjectState* readLatencyChild = iuState->childByName(IU_LATENCY);
        iu->setAttribute(
            ImmediateUnit::OSKEY_LATENCY, readLatencyChild->stringValue());
    } else {
        iu->setAttribute(ImmediateUnit::OSKEY_LATENCY, 1);
    }
 
    setIUExtensionMode(iuState, iu);
 
    // set ports and instruction templates
    for (int i = 0; i < iuState->childCount(); i++) {
        ObjectState* child = iuState->child(i);
        if (child->name() == PORT) {
            iu->addChild(machineRFPort(child));
        } else if (child->name() == IU_TEMPLATE) {
            try {
                instructionTemplateToMachine(
                    child, machineState, iuState->stringAttribute(IU_NAME));
            } catch (const SerializerException&) {
                delete iu;
                throw;
            }
        }
    }
 
    // if machine has an empty instruction template, it must be found in the
    // immediate unit declaration
    if (hasEmptyInstructionTemplate(machineState)) {
        bool emptyFound = false;
        for (int i = 0; i < iuState->childCount(); i++) {
            ObjectState* child = iuState->child(i);
            if (child->name() == IU_TEMPLATE && child->childCount() == 0) {
                emptyFound = true;
                break;
            }
        }
        if (!emptyFound) {
            delete iu;
            ADFSerializerTextGenerator textGen;
            format errorMsg = textGen.text(
                ADFSerializerTextGenerator::TXT_EMPTY_IT_NOT_DECLARED);
            errorMsg % iuState->stringAttribute(IU_NAME);
            string procName = "ADFSerializer::immediateUnitToMachine";
            throw SerializerException(
                __FILE__, __LINE__, procName, errorMsg.str());
        }
    }
 
    return iu;
}

References Application::abortProgram(), ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), hasEmptyInstructionTemplate(), instructionTemplateToMachine(), IU_GUARD_LATENCY, IU_LATENCY, IU_MAX_READS, IU_MAX_WRITES, IU_NAME, IU_SIZE, IU_TEMPLATE, IU_TYPE, IU_TYPE_NORMAL, IU_TYPE_RESERVED, IU_TYPE_VOLATILE, IU_WIDTH, machineRFPort(), ObjectState::name(), PORT, ObjectState::setAttribute(), setIUExtensionMode(), ObjectState::stringAttribute(), ObjectState::stringValue(), Texts::TextGenerator::text(), ADFSerializerTextGenerator::TXT_EMPTY_IT_NOT_DECLARED, and Application::writeToErrorLog().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

immediateUnitToMDF()

ObjectState * ADFSerializer::immediateUnitToMDF ( const ObjectState *  iuState, const ObjectState *  machineState  )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by ImmediateUnit::saveState. The whole ObjectState tree created by Machine::saveState must be given too because instruction templates are needed too to create the new ObjectState tree.

Parameters

iuState	Root node of the ObjectState tree created by ImmediateUnit::saveState.
machineState	The ObjectState tree created by Machine::saveState.

Returns

The newly created ObjectState tree.

Definition at line 751 of file ADFSerializer.cc.

                                                                   {
 
    ObjectState* iUnit = new ObjectState(IMMEDIATE_UNIT);
    string iuName = iuState->stringAttribute(ImmediateUnit::OSKEY_NAME);
    iUnit->setAttribute(IU_NAME, iuName);
 
    // type
    ObjectState* type = new ObjectState(IU_TYPE);
    iUnit->addChild(type);
    string typeValue = iuState->stringAttribute(RegisterFile::OSKEY_TYPE);
    if (typeValue == ImmediateUnit::OSVALUE_NORMAL) {
        type->setValue(IU_TYPE_NORMAL);
    } else if (typeValue == ImmediateUnit::OSVALUE_RESERVED) {
        type->setValue(IU_TYPE_RESERVED);
    } else if (typeValue == ImmediateUnit::OSVALUE_VOLATILE) {
        type->setValue(IU_TYPE_VOLATILE);
    } else {
        string procName = "ADFSerializer::immediateUnitToMDF";
        string errorMsg = "Unknown immediate unit type in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
    
    // add size element
    ObjectState* size = new ObjectState(IU_SIZE);
    iUnit->addChild(size);
    size->setValue(iuState->stringAttribute(ImmediateUnit::OSKEY_SIZE));
 
    // add width element
    ObjectState* width = new ObjectState(IU_WIDTH);
    iUnit->addChild(width);
    width->setValue(iuState->stringAttribute(ImmediateUnit::OSKEY_WIDTH));
 
    // add max reads
    ObjectState* maxReads = new ObjectState(RF_MAX_READS);
    iUnit->addChild(maxReads);
    maxReads->setValue(
        iuState->stringAttribute(RegisterFile::OSKEY_MAX_READS));
 
    // add max writes
    ObjectState* maxWrites = new ObjectState(IU_MAX_WRITES);
    iUnit->addChild(maxWrites);
    maxWrites->setValue(
        iuState->stringAttribute(RegisterFile::OSKEY_MAX_WRITES));
 
    // add guard latency
    if (iuState->intAttribute(ImmediateUnit::OSKEY_GUARD_LATENCY) > 0) {
        ObjectState* guardLatency = new ObjectState(IU_GUARD_LATENCY);
        iUnit->addChild(guardLatency);
        guardLatency->setValue(
            iuState->stringAttribute(ImmediateUnit::OSKEY_GUARD_LATENCY));
    }
 
    // add read latency element
    ObjectState* readLatency = new ObjectState(IU_LATENCY);
    iUnit->addChild(readLatency);
    readLatency->setValue(
        iuState->stringAttribute(ImmediateUnit::OSKEY_LATENCY));
 
    // add extension element
    ObjectState* extension = new ObjectState(IU_EXTENSION);
    iUnit->addChild(extension);
    extension->setValue(
        iuState->stringAttribute(ImmediateUnit::OSKEY_EXTENSION));
 
    // add ports
    for (int i = 0; i < iuState->childCount(); i++) {
        ObjectState* child = iuState->child(i);
        if (child->name() == RFPort::OSNAME_RFPORT) {
            iUnit->addChild(mdfPort(child));
        }
    }
 
    // add instruction templates
    for (int iTempIndex = 0; iTempIndex < machineState->childCount();
         iTempIndex++) {
        ObjectState* iTemp = machineState->child(iTempIndex);
        if (iTemp->name() ==
            InstructionTemplate::OSNAME_INSTRUCTION_TEMPLATE) {
            instructionTemplateToMDF(iTemp, iUnit);
        }
    }
 
    return iUnit;
}

References Application::abortProgram(), ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), IMMEDIATE_UNIT, instructionTemplateToMDF(), ObjectState::intAttribute(), IU_EXTENSION, IU_GUARD_LATENCY, IU_LATENCY, IU_MAX_WRITES, IU_NAME, IU_SIZE, IU_TYPE, IU_TYPE_NORMAL, IU_TYPE_RESERVED, IU_TYPE_VOLATILE, IU_WIDTH, mdfPort(), ObjectState::name(), RF_MAX_READS, ObjectState::setAttribute(), ObjectState::setValue(), ObjectState::stringAttribute(), and Application::writeToErrorLog().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

instructionTemplateToMachine()

void ADFSerializer::instructionTemplateToMachine ( const ObjectState *  mdfITState, ObjectState *  momMachineState, const std::string &  iuName = std::string("")  )

staticprivate

Adds/modifies instruction templates to the given ObjectState instance representing machine in machine object model format.

Instruction templates are read from the given ObjectState instance representing a template element inside immediate unit declaration of mdf.

Parameters

mdfITState	ObjectState instance representing a template element.
momMachineState	ObjectState instance representing a machine in machine object model format.
iuName	Name of the immediate unit which contains the template element.

Exceptions

SerializerException

If an error is occurred while processing.

Definition at line 2215 of file ADFSerializer.cc.

                             {
    const string procName = "ADFSerializer::instructionTemplateToMachine";
 
    string templateName = mdfITState->stringAttribute(IU_TEMPLATE_NAME);
    ObjectState* iTemp = NULL;
    bool iTempFound = false;
 
    for (int iTempIndex = 0; iTempIndex < momMachineState->childCount();
         iTempIndex++) {
        iTemp = momMachineState->child(iTempIndex);
        if (iTemp->name() ==
            InstructionTemplate::OSNAME_INSTRUCTION_TEMPLATE &&
            iTemp->stringAttribute(Component::OSKEY_NAME) ==
            templateName) {
            iTempFound = true;
            break;
        }
    }
 
    if (!iTempFound) {
        iTemp = new ObjectState(
            InstructionTemplate::OSNAME_INSTRUCTION_TEMPLATE);
        momMachineState->addChild(iTemp);
        iTemp->setAttribute(Component::OSKEY_NAME, templateName);
    }
 
    ADFSerializerTextGenerator textGen;
 
    if ((mdfITState->childCount() == 0 && iTempFound &&
         iTemp->childCount() > 0) ||
        (mdfITState->childCount() > 0 && iTempFound &&
         iTemp->childCount() == 0)) {
        format errorMsg = textGen.text(
            ADFSerializerTextGenerator::TXT_IT_EMPTY_AND_NON_EMPTY);
        errorMsg % templateName;
        throw SerializerException(
            __FILE__, __LINE__, procName, errorMsg.str());
    }
 
    for (int slotIndex = 0; slotIndex < mdfITState->childCount();
         slotIndex++) {
        ObjectState* slot = mdfITState->child(slotIndex);
        string slotName =
            slot->childByName(IU_TEMPLATE_SLOT_NAME)->stringValue();
        string width =
            slot->childByName(IU_TEMPLATE_SLOT_WIDTH)->stringValue();
 
        ObjectState* iTempSlot = momTemplateSlot(iTemp, slotName);
        if (iTempSlot == NULL) {
            iTempSlot = new ObjectState(TemplateSlot::OSNAME_TEMPLATE_SLOT);
            iTempSlot->setAttribute(TemplateSlot::OSKEY_SLOT, slotName);
            iTempSlot->setAttribute(TemplateSlot::OSKEY_WIDTH, width);
            iTempSlot->setAttribute(TemplateSlot::OSKEY_DESTINATION, iuName);
            iTemp->addChild(iTempSlot);
        } else {
            format errorMsg;
            if (iTempSlot->stringAttribute(TemplateSlot::OSKEY_DESTINATION) ==
                iuName) {
                errorMsg = textGen.text(
                    ADFSerializerTextGenerator::TXT_SAME_TEMPLATE_SLOT);
                errorMsg % slotName % iuName % templateName;
            } else {
                errorMsg = textGen.text(
                    ADFSerializerTextGenerator::
                        TXT_MULTIPLE_DESTINATIONS_IN_TEMPLATE_SLOT);
                errorMsg % slotName % templateName % iuName %
                    iTempSlot->stringAttribute(
                        TemplateSlot::OSKEY_DESTINATION);
            }
            throw SerializerException(
                __FILE__, __LINE__, procName, errorMsg.str());
        }
    }
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), IU_TEMPLATE_NAME, IU_TEMPLATE_SLOT_NAME, IU_TEMPLATE_SLOT_WIDTH, momTemplateSlot(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::stringAttribute(), ObjectState::stringValue(), Texts::TextGenerator::text(), ADFSerializerTextGenerator::TXT_IT_EMPTY_AND_NON_EMPTY, and ADFSerializerTextGenerator::TXT_SAME_TEMPLATE_SLOT.

Referenced by convertToMachineFormat(), and immediateUnitToMachine().

Here is the call graph for this function:

instructionTemplateToMDF()

void ADFSerializer::instructionTemplateToMDF ( const ObjectState *  momITState, ObjectState *  mdfIUState  )

staticprivate

Includes the given instruction template information to ObjectState tree representing immediate unit in mdf format.

Parameters

momITState	ObjectState instance representing an instruction template in machine object model format.
mdfIUState	ObjectState instance representing an immediate unit in mdf format.

Definition at line 2149 of file ADFSerializer.cc.

                             {
 
    string iuName = mdfIUState->stringAttribute(IU_NAME);
    string iTempName = momITState->stringAttribute(Component::OSKEY_NAME);
    for (int slotIndex = 0; slotIndex < momITState->childCount();
         slotIndex++) {
        ObjectState* slot = momITState->child(slotIndex);
        if (slot->stringAttribute(TemplateSlot::OSKEY_DESTINATION) ==
            iuName) {
            ObjectState* correctTemplate = NULL;
 
            for (int iuChildIndex = 0;
                 iuChildIndex < mdfIUState->childCount(); iuChildIndex++) {
                ObjectState* iuChild = mdfIUState->child(iuChildIndex);
                if (iuChild->name() == IU_TEMPLATE &&
                    iuChild->stringAttribute(IU_TEMPLATE_NAME) == iTempName) {
                    correctTemplate = iuChild;
                }
            }
 
            if (correctTemplate == NULL) {
                correctTemplate = new ObjectState(IU_TEMPLATE);
                mdfIUState->addChild(correctTemplate);
                correctTemplate->setAttribute(IU_TEMPLATE_NAME, iTempName);
            }
 
            ObjectState* slotElem = new ObjectState(IU_TEMPLATE_SLOT);
            correctTemplate->addChild(slotElem);
            ObjectState* nameElem = new ObjectState(IU_TEMPLATE_SLOT_NAME);
            slotElem->addChild(nameElem);
            nameElem->setValue(
                slot->stringAttribute(TemplateSlot::OSKEY_SLOT));
            ObjectState* widthElem = new ObjectState(IU_TEMPLATE_SLOT_WIDTH);
            slotElem->addChild(widthElem);
            widthElem->setValue(
                slot->stringAttribute(TemplateSlot::OSKEY_WIDTH));
        }
    }
 
 
    if (momITState->childCount() == 0) {
        ObjectState* emptyTemplate = new ObjectState(IU_TEMPLATE);
        mdfIUState->addChild(emptyTemplate);
        emptyTemplate->setAttribute(IU_TEMPLATE_NAME, iTempName);
    }
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), IU_NAME, IU_TEMPLATE, IU_TEMPLATE_NAME, IU_TEMPLATE_SLOT, IU_TEMPLATE_SLOT_NAME, IU_TEMPLATE_SLOT_WIDTH, ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by immediateUnitToMDF().

Here is the call graph for this function:

machineFUPort()

ObjectState * ADFSerializer::machineFUPort ( const ObjectState *  mdfFUPortState )

staticprivate

Creates an ObjectState instance that represent a function unit port in machine object model format.

The ObjectState instance is created according to the given ObjectState instance that represents a function unit port in mdf format. The given instance must have an attribute called 'name' and up to two 'connects-to' children. It has also 'width' child and may also have 'triggers' and 'setsOpcode' children.

Parameters

mdfFUPortState

ObjectState instance representing a function port in mdf format.

Returns

The newly created ObjectState instance representing a function unit port in machine object model format.

Definition at line 1863 of file ADFSerializer.cc.

                                                              {
 
    ObjectState* fuPort = new ObjectState(FUPort::OSNAME_FUPORT);
    fuPort->setAttribute(Port::OSKEY_NAME, mdfFUPortState->stringAttribute(
                             PORT_NAME));
 
    // set socket connections
    for (int i = 0; i < mdfFUPortState->childCount(); i++) {
        ObjectState* portChild = mdfFUPortState->child(i);
        if (portChild->name() == PORT_CONNECTS_TO) {
            if (!fuPort->hasAttribute(Port::OSKEY_FIRST_SOCKET)) {
                fuPort->setAttribute(
                    Port::OSKEY_FIRST_SOCKET, portChild->stringValue());
            } else {
                fuPort->setAttribute(
                    Port::OSKEY_SECOND_SOCKET, portChild->stringValue());
            }
        }
    }
 
    // set other attributes
    ObjectState* width = mdfFUPortState->childByName(FU_PORT_WIDTH);
    fuPort->setAttribute(FUPort::OSKEY_WIDTH, width->stringValue());
    fuPort->setAttribute(
        FUPort::OSKEY_TRIGGERING, mdfFUPortState->hasChild(
            FU_PORT_TRIGGERS));
    fuPort->setAttribute(
        FUPort::OSKEY_OPCODE_SETTING, mdfFUPortState->hasChild(
            FU_PORT_SETS_OPCODE));
    fuPort->setAttribute(
        FUPort::OSKEY_NO_REGISTER, mdfFUPortState->hasChild(
            FU_PORT_NO_REGISTER));
 
    return fuPort;
}

References ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FU_PORT_NO_REGISTER, FU_PORT_SETS_OPCODE, FU_PORT_TRIGGERS, FU_PORT_WIDTH, ObjectState::hasAttribute(), ObjectState::hasChild(), ObjectState::name(), PORT_CONNECTS_TO, PORT_NAME, ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by controlUnitToMachine(), and functionUnitToMachine().

Here is the call graph for this function:

machineOperation()

ObjectState * ADFSerializer::machineOperation ( const ObjectState *  mdfOperationState )

staticprivate

Creates an ObjectState instance that represents an operation in machine object model format.

The ObjectState instance is created according to the given ObjectState instance that represents an operation in mdf format.

Parameters

mdfOperationState

ObjectState instance representing an operation in mdf format.

Returns

The newly created ObjectState instance representing an operation in machine object model format.

Definition at line 1949 of file ADFSerializer.cc.

                                                                    {
 
    ObjectState* machineOperation = new ObjectState(
        HWOperation::OSNAME_OPERATION);
    machineOperation->setAttribute(
        HWOperation::OSKEY_NAME,
        mdfOperationState->childByName(FU_OP_NAME)->stringValue());
 
    // set operand bindings
    for (int i = 0; i < mdfOperationState->childCount(); i++) {
        ObjectState* child = mdfOperationState->child(i);
        if (child->name() == FU_OP_BIND) {
            ObjectState* binding = new ObjectState(
                HWOperation::OSNAME_OPERAND_BINDING);
            machineOperation->addChild(binding);
            binding->setAttribute(
                HWOperation::OSKEY_OPERAND,
                child->stringAttribute(FU_OP_BIND_NAME));
            binding->setAttribute(
                HWOperation::OSKEY_PORT, child->stringValue());
        }
    }
 
    // set pipeline
    ObjectState* mdfPipeline = mdfOperationState->childByName(
        FU_OP_PIPELINE);
    machineOperation->addChild(machinePipeline(mdfPipeline));
 
    return machineOperation;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FU_OP_BIND, FU_OP_BIND_NAME, FU_OP_NAME, FU_OP_PIPELINE, machinePipeline(), mdfPipeline(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by controlUnitToMachine(), and functionUnitToMachine().

Here is the call graph for this function:

machinePipeline()

ObjectState * ADFSerializer::machinePipeline ( const ObjectState *  mdfPipelineState )

staticprivate

Creates an ObjectState instance that represents a pipeline in machine object model format.

The ObjectState instance is created according to the given ObjectState instance that represents a pipeline in mdf format.

Parameters

mdfPipelineState

ObjectState instance representing a pipeline in mdf format.

Returns

The newly created ObjectState instance representing a pipeline in machine object model format.

Definition at line 2035 of file ADFSerializer.cc.

                                                                  {
 
    ObjectState* machinePipeline = new ObjectState(
        ExecutionPipeline::OSNAME_PIPELINE);
 
    for (int i = 0; i < mdfPipelineState->childCount(); i++) {
        ObjectState* mdfResource = mdfPipelineState->child(i);
        ObjectState* machineResource = NULL;
        if (mdfResource->name() == FU_OP_PL_RESOURCE) {
            machineResource = new ObjectState(
                ExecutionPipeline::OSNAME_RESOURCE_USAGE);
            machineResource->setAttribute(
                ExecutionPipeline::OSKEY_RESOURCE_NAME,
                mdfResource->stringAttribute(FU_OP_PL_RES_NAME));
        } else if (mdfResource->name() == FU_OP_PL_READS) {
            machineResource = new ObjectState(
                ExecutionPipeline::OSNAME_OPERAND_READ);
            machineResource->setAttribute(
                ExecutionPipeline::OSKEY_OPERAND,
                mdfResource->stringAttribute(FU_OP_PL_READS_NAME));
        } else if (mdfResource->name() == FU_OP_PL_WRITES) {
            machineResource = new ObjectState(
                ExecutionPipeline::OSNAME_OPERAND_WRITE);
            machineResource->setAttribute(
                ExecutionPipeline::OSKEY_OPERAND,
                mdfResource->stringAttribute(FU_OP_PL_WRITES_NAME));
        } else {
            const string procName = "ADFSerializer::machinePipeline";
            const string errorMsg = "Given pipeline model is invalid.";
            Application::writeToErrorLog(
                __FILE__, __LINE__, procName, errorMsg);
            Application::abortProgram();
        }
 
        machinePipeline->addChild(machineResource);
        machineResource->setAttribute(
            ExecutionPipeline::OSKEY_START_CYCLE,
            mdfResource->childByName(FU_OP_PL_RES_START_CYCLE)->
            stringValue());
        machineResource->setAttribute(
            ExecutionPipeline::OSKEY_CYCLES,
            mdfResource->childByName(FU_OP_PL_RES_CYCLES)->stringValue());
    }
 
    return machinePipeline;
}

References Application::abortProgram(), ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FU_OP_PL_READS, FU_OP_PL_READS_NAME, FU_OP_PL_RES_CYCLES, FU_OP_PL_RES_NAME, FU_OP_PL_RES_START_CYCLE, FU_OP_PL_RESOURCE, FU_OP_PL_WRITES, FU_OP_PL_WRITES_NAME, ObjectState::name(), ObjectState::setAttribute(), ObjectState::stringAttribute(), ObjectState::stringValue(), and Application::writeToErrorLog().

Referenced by machineOperation().

Here is the call graph for this function:

machineRFPort()

ObjectState * ADFSerializer::machineRFPort ( const ObjectState *  mdfPortState )

staticprivate

Creates an ObjectState instance that represents a register file port in machine object model format.

The ObjectState instance is created according to the given ObjectState instance that represents a port in mdf format. The given instance must have an attribute called 'name' and up to two 'connects-to' children.

Parameters

mdfPortState

ObjectState instance representing a normal port in mdf format.

Returns

The newly created ObjectState instance representing a normal port in machine object model format.

Definition at line 1792 of file ADFSerializer.cc.

                                                            {
 
    ObjectState* port = new ObjectState(RFPort::OSNAME_RFPORT);
    port->setAttribute(
        RFPort::OSKEY_NAME, mdfPortState->stringAttribute(PORT_NAME));
 
    for (int i = 0; i < mdfPortState->childCount(); i++) {
        ObjectState* conn = mdfPortState->child(i);
        if (i == 0) {
            port->setAttribute(
                Port::OSKEY_FIRST_SOCKET, conn->stringValue());
        } else {
            port->setAttribute(
                Port::OSKEY_SECOND_SOCKET, conn->stringValue());
        }
    }
 
    return port;
}

References ObjectState::child(), ObjectState::childCount(), PORT_NAME, ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by immediateUnitToMachine(), and registerFileToMachine().

Here is the call graph for this function:

machineSRPort()

ObjectState * ADFSerializer::machineSRPort ( const ObjectState *  mdfSRPortState )

staticprivate

Creates an ObjectState instance that represents a special register port in machine object model format.

The ObjectState instance is created according to the given ObjectState instance that represents a special register port in mdf format.

Parameters

mdfSRPortState

ObjectState instance representing a special register port in mdf format.

Returns

The newly created ObjectState instance representing a special register port in machine object model format.

Definition at line 1659 of file ADFSerializer.cc.

                                                              {
 
    assert(mdfSRPortState->name() == CU_SPECIAL_PORT);
    ObjectState* machPort =
        new ObjectState(SpecialRegisterPort::OSNAME_SPECIAL_REG_PORT);
    machPort->setAttribute(
        SpecialRegisterPort::OSKEY_NAME,
        mdfSRPortState->stringAttribute(PORT_NAME));
 
    ObjectState* width = mdfSRPortState->childByName(FU_PORT_WIDTH);
    machPort->setAttribute(
        SpecialRegisterPort::OSKEY_WIDTH, width->stringValue());
 
    int connIndex = 0;
    for (int i = 0; i < mdfSRPortState->childCount(); i++) {
        ObjectState* child = mdfSRPortState->child(i);
        if (child->name() == PORT_CONNECTS_TO) {
            connIndex++;
            if (connIndex == 1) {
                machPort->setAttribute(
                    Port::OSKEY_FIRST_SOCKET, child->stringValue());
            } else if (connIndex == 2) {
                machPort->setAttribute(
                    Port::OSKEY_SECOND_SOCKET, child->stringValue());
            } else {
                string procName = "ADFSerializer::machineSRPort";
                string errorMsg = "Too many connects-to elements in SR "
                    "port.";
                Application::writeToErrorLog(
                    __FILE__, __LINE__, procName, errorMsg);
                Application::abortProgram();
            }
        }
    }
 
    return machPort;
}

References Application::abortProgram(), assert, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), CU_SPECIAL_PORT, FU_PORT_WIDTH, ObjectState::name(), PORT_CONNECTS_TO, PORT_NAME, ObjectState::setAttribute(), ObjectState::stringAttribute(), ObjectState::stringValue(), and Application::writeToErrorLog().

Referenced by controlUnitToMachine().

Here is the call graph for this function:

mdfFUPort()

ObjectState * ADFSerializer::mdfFUPort ( const ObjectState *  machineFUPortState )

staticprivate

Creates an ObjectState instance that represents a function unit port in mdf format.

The ObjectState instance is created according to the given ObjectState instance that represents a function unit port in machine object model format.

Parameters

machineFUPortState

ObjectState instance representing a function unit port in machine object model format.

Returns

The newly created ObjectState instance representing a function unit port in mdf format.

Definition at line 1914 of file ADFSerializer.cc.

                                                              {
 
    ObjectState* mdfFUPort = mdfPort(machineFUPortState);
    ObjectState* width = new ObjectState(FU_PORT_WIDTH);
    width->setValue(machineFUPortState->stringAttribute(
                        FUPort::OSKEY_WIDTH));
    mdfFUPort->addChild(width);
    if (machineFUPortState->intAttribute(FUPort::OSKEY_TRIGGERING)) {
        mdfFUPort->addChild(new ObjectState(FU_PORT_TRIGGERS));
    }
    if (machineFUPortState->intAttribute(FUPort::OSKEY_OPCODE_SETTING)) {
        mdfFUPort->addChild(new ObjectState(FU_PORT_SETS_OPCODE));
    }
 
    if (machineFUPortState->intAttribute(FUPort::OSKEY_NO_REGISTER)) {
        mdfFUPort->addChild(new ObjectState(FU_PORT_NO_REGISTER));        
    } 
 
    return mdfFUPort;
}

References ObjectState::addChild(), FU_PORT_NO_REGISTER, FU_PORT_SETS_OPCODE, FU_PORT_TRIGGERS, FU_PORT_WIDTH, ObjectState::intAttribute(), mdfPort(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by controlUnitToMDF(), and functionUnitToMDF().

Here is the call graph for this function:

mdfOperation()

ObjectState * ADFSerializer::mdfOperation ( const ObjectState *  machineOperationState )

staticprivate

Creates an ObjectState instance that represents an operation in mdf format.

The ObjectState instance is created according to the given ObjectState instance that represents an operation in machine object model format.

Parameters

machineOperationState

ObjectState instance representing an operation in machine object model format.

Returns

The newly created ObjectState instance representing an operation in mdf format.

Definition at line 1994 of file ADFSerializer.cc.

                                                                    {
 
    ObjectState* mdfOperation = new ObjectState(FU_OPERATION);
    ObjectState* name = new ObjectState(FU_OP_NAME);
    mdfOperation->addChild(name);
    name->setValue(machineOperationState->stringAttribute(
                       HWOperation::OSKEY_NAME));
 
    // add bind elements
    for (int i = 0; i < machineOperationState->childCount(); i++) {
        ObjectState* child = machineOperationState->child(i);
        if (child->name() == HWOperation::OSNAME_OPERAND_BINDING) {
            ObjectState* bind = new ObjectState(FU_OP_BIND);
            mdfOperation->addChild(bind);
            bind->setAttribute(
                FU_OP_BIND_NAME, child->stringAttribute(
                    HWOperation::OSKEY_OPERAND));
            bind->setValue(child->stringAttribute(HWOperation::OSKEY_PORT));
        }
    }
 
    ObjectState* machPipeline = machineOperationState->childByName(
        ExecutionPipeline::OSNAME_PIPELINE);
    mdfOperation->addChild(mdfPipeline(machPipeline));
    return mdfOperation;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FU_OP_BIND, FU_OP_BIND_NAME, FU_OP_NAME, FU_OPERATION, mdfPipeline(), ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by controlUnitToMDF(), and functionUnitToMDF().

Here is the call graph for this function:

mdfPipeline()

ObjectState * ADFSerializer::mdfPipeline ( const ObjectState *  machinePipelineState )

staticprivate

Creates an ObjectState instance that represents a pipeline in mdf format.

The ObjectState instance is created according to the given ObjectState instance that represents a pipeline in machine object model format.

Parameters

machinePipelineState

ObjectState instance representing a pipeline in machine object model format.

Returns

The newly created ObjectState instance representing a pipeline in mdf format.

Definition at line 2095 of file ADFSerializer.cc.

                                                                  {
 
    ObjectState* mdfPipeline = new ObjectState(FU_OP_PIPELINE);
 
    for (int i = 0; i < machinePipelineState->childCount(); i++) {
        ObjectState* resChild = machinePipelineState->child(i);
        ObjectState* mdfChild = NULL;
        if (resChild->name() == ExecutionPipeline::OSNAME_RESOURCE_USAGE) {
            mdfChild = new ObjectState(FU_OP_PL_RESOURCE);
            mdfChild->setAttribute(
                FU_OP_PL_RES_NAME,
                resChild->stringAttribute(
                    ExecutionPipeline::OSKEY_RESOURCE_NAME));
        } else if (resChild->name() ==
                   ExecutionPipeline::OSNAME_OPERAND_READ) {
            mdfChild = new ObjectState(FU_OP_PL_READS);
            mdfChild->setAttribute(
                FU_OP_PL_READS_NAME,
                resChild->stringAttribute(ExecutionPipeline::OSKEY_OPERAND));
        } else if (resChild->name() ==
                   ExecutionPipeline::OSNAME_OPERAND_WRITE) {
            mdfChild = new ObjectState(FU_OP_PL_WRITES);
            mdfChild->setAttribute(
                FU_OP_PL_WRITES_NAME,
                resChild->stringAttribute(ExecutionPipeline::OSKEY_OPERAND));
        } else {
            assert(false);
        }
 
        mdfPipeline->addChild(mdfChild);
        ObjectState* startCycle = new ObjectState(FU_OP_PL_RES_START_CYCLE);
        mdfChild->addChild(startCycle);
        startCycle->setValue(
            resChild->stringAttribute(ExecutionPipeline::OSKEY_START_CYCLE));
        ObjectState* cycles = new ObjectState(FU_OP_PL_RES_CYCLES);
        mdfChild->addChild(cycles);
        cycles->setValue(
            resChild->stringAttribute(ExecutionPipeline::OSKEY_CYCLES));
    }
 
    return mdfPipeline;
}

References ObjectState::addChild(), assert, ObjectState::child(), ObjectState::childCount(), FU_OP_PIPELINE, FU_OP_PL_READS, FU_OP_PL_READS_NAME, FU_OP_PL_RES_CYCLES, FU_OP_PL_RES_NAME, FU_OP_PL_RES_START_CYCLE, FU_OP_PL_RESOURCE, FU_OP_PL_WRITES, FU_OP_PL_WRITES_NAME, ObjectState::name(), ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by machineOperation(), and mdfOperation().

Here is the call graph for this function:

mdfPort()

ObjectState * ADFSerializer::mdfPort ( const ObjectState *  machinePortState )

staticprivate

Creates an ObjectState instance that represents a normal port in mdf format.

The ObjectState instance is created according to the given ObjectState instance that represents a port in machine object model format.

Parameters

machinePortState

ObjectState instance representing a normal port in machine object model format.

Returns

The newly created ObjectState instance representing a normal port in mdf format.

Definition at line 1826 of file ADFSerializer.cc.

                                                          {
 
    ObjectState* mdfPort = new ObjectState(PORT);
    mdfPort->setAttribute(PORT_NAME, machinePortState->stringAttribute(
                              Port::OSKEY_NAME));
    if (machinePortState->hasAttribute(Port::OSKEY_FIRST_SOCKET)) {
        ObjectState* conn = new ObjectState(PORT_CONNECTS_TO);
        mdfPort->addChild(conn);
        conn->setValue(machinePortState->stringAttribute(
                           Port::OSKEY_FIRST_SOCKET));
    }
    if (machinePortState->hasAttribute(Port::OSKEY_SECOND_SOCKET)) {
        ObjectState* conn = new ObjectState(PORT_CONNECTS_TO);
        mdfPort->addChild(conn);
        conn->setValue(machinePortState->stringAttribute(
                           Port::OSKEY_SECOND_SOCKET));
    }
    return mdfPort;
}

References ObjectState::addChild(), ObjectState::hasAttribute(), PORT, PORT_CONNECTS_TO, PORT_NAME, ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by immediateUnitToMDF(), mdfFUPort(), and registerFileToMDF().

Here is the call graph for this function:

mdfSRPort()

ObjectState * ADFSerializer::mdfSRPort ( const ObjectState *  machineSRPortState )

staticprivate

Creates an ObjectState instance that represents a special register port in mdf format.

The ObjectState instance is created according to the given ObjectState instance that represents a special register port in machine object model format.

Parameters

machineSRPortState

ObjectState instance representing a special register port in machine object model format.

Returns

The newly created ObjectState instance representing a special register port in mdf format.

Definition at line 1712 of file ADFSerializer.cc.

                                                              {
 
    assert(machineSRPortState->name() ==
           SpecialRegisterPort::OSNAME_SPECIAL_REG_PORT);
 
    ObjectState* mdfSRPort = new ObjectState(CU_SPECIAL_PORT);
    string name =
        machineSRPortState->stringAttribute(SpecialRegisterPort::OSKEY_NAME);
    mdfSRPort->setAttribute(PORT_NAME, name);
 
    if (machineSRPortState->hasAttribute(FUPort::OSKEY_FIRST_SOCKET)) {
        ObjectState* conn = new ObjectState(PORT_CONNECTS_TO);
        mdfSRPort->addChild(conn);
        conn->setValue(machineSRPortState->stringAttribute(
                           FUPort::OSKEY_FIRST_SOCKET));
    }
 
    if (machineSRPortState->hasAttribute(FUPort::OSKEY_SECOND_SOCKET)) {
        ObjectState* conn = new ObjectState(PORT_CONNECTS_TO);
        mdfSRPort->addChild(conn);
        conn->setValue(machineSRPortState->stringAttribute(
                           FUPort::OSKEY_SECOND_SOCKET));
    }
 
    ObjectState* width = new ObjectState(FU_PORT_WIDTH);
    mdfSRPort->addChild(width);
    width->setValue(
        machineSRPortState->stringAttribute(
            SpecialRegisterPort::OSKEY_WIDTH));
 
    return mdfSRPort;
}

References ObjectState::addChild(), assert, CU_SPECIAL_PORT, FU_PORT_WIDTH, ObjectState::hasAttribute(), ObjectState::name(), PORT_CONNECTS_TO, PORT_NAME, ObjectState::setAttribute(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by controlUnitToMDF().

Here is the call graph for this function:

momTemplateSlot()

ObjectState * ADFSerializer::momTemplateSlot ( const ObjectState *  momITState, const std::string &  slotName  )

staticprivate

Looks for an ObjectState instance which represents a template slot in machine object model format.

The ObjectState instance is searched from inside the given ObjectState instance that represents an instruction template in machine object model format. The instance is seached by the given slot name. Returns NULL if such an instance is not found.

Parameters

momITState	An ObjectState instance representing an instruction template in machine object model format.
busName	The name of the slot to look the template slot for.

Returns

ObjectState instance representing a template slot in machine object model format or NULL.

Definition at line 2308 of file ADFSerializer.cc.

                               {
 
    for (int i = 0; i < momITState->childCount(); i++) {
        ObjectState* slot = momITState->child(i);
        if (slot->stringAttribute(TemplateSlot::OSKEY_SLOT) == slotName) {
            return slot;
        }
    }
 
    return NULL;
}

References ObjectState::child(), ObjectState::childCount(), and ObjectState::stringAttribute().

Referenced by instructionTemplateToMachine().

Here is the call graph for this function:

operator=()

ADFSerializer& ADFSerializer::operator= ( const ADFSerializer &  )

protected

Assingment forbidden.

readMachine()

Machine * ADFSerializer::readMachine

(

)

Reads the current MDF file set and creates a Machine according to it.

Returns

The newly created machine.

Exceptions

SerializerException	If an error occurs while reading the MDF file.
ObjectStateLoadingException	If an error occurs while creating Machine.

Definition at line 275 of file ADFSerializer.cc.

                           {
    ObjectState* machineState = readState();
    Machine* mach = new Machine();
    mach->loadState(machineState);
 
    delete machineState;
    return mach;
}

References TTAMachine::Machine::loadState(), and readState().

Referenced by llvm::TCETargetMachine::createMachine(), AddFUArchFromADFCmd::Do(), TTAMachine::Machine::loadFromADF(), loadInputs(), loadMachine(), ProGe::ProGeUI::loadMachine(), SimulatorFrontend::loadMachine(), ProGe::ProGeUI::loadProcessorConfiguration(), main(), Model::Model(), readAdf(), and llvm::TCEStubTargetMachine::TCEStubTargetMachine().

Here is the call graph for this function:

readState()

ObjectState * ADFSerializer::readState ( )

virtual

Reads the current MDF file set and creates an ObjectState tree which can be given to Machine::loadState to create a machine.

Returns

The newly created ObjectState tree.

Exceptions

SerializerException

If an error occurs while reading.

Reimplemented from XMLSerializer.

Definition at line 238 of file ADFSerializer.cc.

                         {
    ObjectState* mdfState = XMLSerializer::readState();
    ObjectState* machineState;
    try {
        machineState = convertToMachineFormat(mdfState);
    } catch (const SerializerException&) {
        delete mdfState;
        throw;
    }
 
    delete mdfState;
    return machineState;
}

References convertToMachineFormat(), and XMLSerializer::readState().

Referenced by DSDBManager::architecture(), readMachine(), and DSDBManager::writeArchitectureToFile().

Here is the call graph for this function:

registerFileToMachine()

ObjectState * ADFSerializer::registerFileToMachine ( const ObjectState *  rfState )

staticprivate

Creates a new ObjectState tree which can be read by RegisterFile::loadState.

The ObjectState tree is created according to the given ObjectState tree which matches with the syntax of register file declaration in MDF file.

Parameters

rfState

The ObjectState tree which matches with the syntax of register file declaration in MDF file.

Returns

The newly created ObjectState tree.

Definition at line 1304 of file ADFSerializer.cc.

                                                               {
 
    ObjectState* regFile =
        new ObjectState(RegisterFile::OSNAME_REGISTER_FILE);
 
    // set name
    regFile->setAttribute(
        Component::OSKEY_NAME, rfState->stringAttribute(RF_NAME));
 
    // set type
    ObjectState* typeChild = rfState->childByName(RF_TYPE);
    string type = typeChild->stringValue();
    if (type == RF_TYPE_NORMAL) {
        regFile->setAttribute(
            RegisterFile::OSKEY_TYPE, RegisterFile::OSVALUE_NORMAL);
    } else if (type == RF_TYPE_RESERVED) {
        regFile->setAttribute(
            RegisterFile::OSKEY_TYPE, RegisterFile::OSVALUE_RESERVED);
    } else if (type == RF_TYPE_VOLATILE) {
        regFile->setAttribute(
            RegisterFile::OSKEY_TYPE, RegisterFile::OSVALUE_VOLATILE);
    } else {
        string procName = "ADFSerializer::registerFileToMachine";
        string errorMsg = "Unknown register file type in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
 
    // set size
    ObjectState* size = rfState->childByName(RF_SIZE);
    regFile->setAttribute(BaseRegisterFile::OSKEY_SIZE, size->stringValue());
 
    // set width
    ObjectState* width = rfState->childByName(RF_WIDTH);
    regFile->setAttribute(
        BaseRegisterFile::OSKEY_WIDTH, width->stringValue());
 
    // set max reads
    ObjectState* maxReads = rfState->childByName(RF_MAX_READS);
    regFile->setAttribute(
        RegisterFile::OSKEY_MAX_READS, maxReads->stringValue());
 
    // set max writes
    ObjectState* maxWrites = rfState->childByName(RF_MAX_WRITES);
    regFile->setAttribute(
        RegisterFile::OSKEY_MAX_WRITES, maxWrites->stringValue());
    
    // set guard latency
    if (rfState->hasChild(RF_GUARD_LATENCY)) {
        ObjectState* latencyChild = rfState->childByName(RF_GUARD_LATENCY);
        regFile->setAttribute(
            RegisterFile::OSKEY_GUARD_LATENCY, latencyChild->stringValue());
    } else {
        regFile->setAttribute(RegisterFile::OSKEY_GUARD_LATENCY, 0);
    }
 
    // set ports
    for (int i = 0; i < rfState->childCount(); i++) {
        ObjectState* child = rfState->child(i);
        if (child->name() == PORT) {
            regFile->addChild(machineRFPort(child));
        }
    }
 
    if (rfState->hasChild(RF_ZERO_REGISTER)) {
        ObjectState* zeroRegister = rfState->childByName(RF_ZERO_REGISTER);
        regFile->setAttribute(
            RegisterFile::OSKEY_ZERO_REGISTER, zeroRegister->boolValue());
    }
 
    return regFile;
}

References Application::abortProgram(), ObjectState::addChild(), ObjectState::boolValue(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), machineRFPort(), ObjectState::name(), PORT, RF_GUARD_LATENCY, RF_MAX_READS, RF_MAX_WRITES, RF_NAME, RF_SIZE, RF_TYPE, RF_TYPE_NORMAL, RF_TYPE_RESERVED, RF_TYPE_VOLATILE, RF_WIDTH, RF_ZERO_REGISTER, ObjectState::setAttribute(), ObjectState::stringAttribute(), ObjectState::stringValue(), and Application::writeToErrorLog().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

registerFileToMDF()

ObjectState * ADFSerializer::registerFileToMDF ( const ObjectState *  rfState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by RegisterFile::saveState.

Parameters

rfState

Root node of the ObjectState tree created by RegisterFile::saveState.

Returns

The newly created ObjectState tree.

Definition at line 671 of file ADFSerializer.cc.

                                                           {
 
    ObjectState* regFile = new ObjectState(REGISTER_FILE);
    regFile->setAttribute(
        RF_NAME, rfState->stringAttribute(RegisterFile::OSKEY_NAME));
 
    ObjectState* type = new ObjectState(RF_TYPE);
    regFile->addChild(type);
    string typeValue = rfState->stringAttribute(RegisterFile::OSKEY_TYPE);
    if (typeValue == RegisterFile::OSVALUE_NORMAL) {
        type->setValue(RF_TYPE_NORMAL);
    } else if (typeValue == RegisterFile::OSVALUE_RESERVED) {
        type->setValue(RF_TYPE_RESERVED);
    } else if (typeValue == RegisterFile::OSVALUE_VOLATILE) {
        type->setValue(RF_TYPE_VOLATILE);
    } else {
        string procName = "ADFSerializer::registerFileToMDF";
        string errorMsg = "Unknown register file type in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
 
    ObjectState* size = new ObjectState(RF_SIZE);
    regFile->addChild(size);
    size->setValue(rfState->stringAttribute(RegisterFile::OSKEY_SIZE));
 
    ObjectState* width = new ObjectState(RF_WIDTH);
    regFile->addChild(width);
    width->setValue(rfState->stringAttribute(RegisterFile::OSKEY_WIDTH));
 
    ObjectState* maxReads = new ObjectState(RF_MAX_READS);
    regFile->addChild(maxReads);
    maxReads->setValue(
        rfState->stringAttribute(RegisterFile::OSKEY_MAX_READS));
 
    ObjectState* maxWrites = new ObjectState(RF_MAX_WRITES);
    regFile->addChild(maxWrites);
    maxWrites->setValue(
        rfState->stringAttribute(RegisterFile::OSKEY_MAX_WRITES));
 
    if (rfState->intAttribute(RegisterFile::OSKEY_GUARD_LATENCY) > 0) {
        ObjectState* guardLatency = new ObjectState(RF_GUARD_LATENCY);
        regFile->addChild(guardLatency);
        guardLatency->setValue(
            rfState->stringAttribute(RegisterFile::OSKEY_GUARD_LATENCY));
    }
 
    // add ports
    for (int i = 0; i < rfState->childCount(); i++) {
        ObjectState* child = rfState->child(i);
        regFile->addChild(mdfPort(child));
    }
 
    if (rfState->hasAttribute(RegisterFile::OSKEY_ZERO_REGISTER)) {
        ObjectState* zeroRegister = new ObjectState(RF_ZERO_REGISTER);
        regFile->addChild(zeroRegister);
        zeroRegister->setValue(
            rfState->boolAttribute(RegisterFile::OSKEY_ZERO_REGISTER));
    }
 
    return regFile;
}

References Application::abortProgram(), ObjectState::addChild(), ObjectState::boolAttribute(), ObjectState::child(), ObjectState::childCount(), ObjectState::hasAttribute(), ObjectState::intAttribute(), mdfPort(), REGISTER_FILE, RF_GUARD_LATENCY, RF_MAX_READS, RF_MAX_WRITES, RF_NAME, RF_SIZE, RF_TYPE, RF_TYPE_NORMAL, RF_TYPE_RESERVED, RF_TYPE_VOLATILE, RF_WIDTH, RF_ZERO_REGISTER, ObjectState::setAttribute(), ObjectState::setValue(), ObjectState::stringAttribute(), and Application::writeToErrorLog().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

setIUExtensionMode()

void ADFSerializer::setIUExtensionMode ( const ObjectState *  mdfIUState, ObjectState *  momIUState  )

staticprivate

Sets extension mode of immediate unit to the given ObjectState tree representing immediate unit in machine object model format.

Parameters

mdfIUState	ObjectState instance representing immediate unit in mdf format.
momIUState	ObjectState instance representing immediate unit in machine object model format.

Definition at line 1756 of file ADFSerializer.cc.

                             {
 
    ObjectState* extension = mdfIUState->childByName(IU_EXTENSION);
    string extensionValue = extension->stringValue();
    if (extensionValue == SIGN_EXTENSION) {
        momIUState->setAttribute(
            ImmediateUnit::OSKEY_EXTENSION, ImmediateUnit::OSVALUE_SIGN);
    } else if (extensionValue == ZERO_EXTENSION) {
        momIUState->setAttribute(
            ImmediateUnit::OSKEY_EXTENSION, ImmediateUnit::OSVALUE_ZERO);
    } else {
        string procName = "ADFSerializer::setIUExtensionMode";
        string errorMsg = "Unknown extension attribute value in ObjectState "
            "instance.";
        Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
        Application::abortProgram();
    }
}

References Application::abortProgram(), ObjectState::childByName(), IU_EXTENSION, ObjectState::setAttribute(), SIGN_EXTENSION, ObjectState::stringValue(), Application::writeToErrorLog(), and ZERO_EXTENSION.

Referenced by immediateUnitToMachine().

Here is the call graph for this function:

socketToMachine()

ObjectState * ADFSerializer::socketToMachine ( const ObjectState *  socketState )

staticprivate

Creates a new ObjectState tree which can be read by Socket::loadState and which corresponds with the given ObjectState tree declaring a socket by MDF syntax.

Parameters

socketState

The ObjectState tree declaring a socket by MDF syntax.

Returns

The newly created ObjectState tree.

Definition at line 1176 of file ADFSerializer.cc.

                                                             {
 
    ObjectState* socket = new ObjectState(Socket::OSNAME_SOCKET);
 
    // set name
    socket->setAttribute(
        Component::OSKEY_NAME, socketState->stringAttribute(SOCKET_NAME));
 
    // set direction
    if (socketState->hasChild(SOCKET_READS_FROM) ||
        socketState->hasChild(SOCKET_WRITES_TO)) {
 
        if (socketState->hasChild(SOCKET_READS_FROM)) {
            socket->setAttribute(
                Socket::OSKEY_DIRECTION, Socket::OSVALUE_INPUT);
        } else {
            socket->setAttribute(
                Socket::OSKEY_DIRECTION, Socket::OSVALUE_OUTPUT);
        }
 
        // add connections
        for (int i = 0; i < socketState->childCount(); i++) {
            ObjectState* srcOrDest = socketState->child(i);
            ObjectState* conn = new ObjectState(
                Connection::OSNAME_CONNECTION);
            socket->addChild(conn);
            conn->setAttribute(
                Connection::OSKEY_SOCKET,
                socketState->stringAttribute(SOCKET_NAME));
            ObjectState* bus = srcOrDest->childByName(SOCKET_BUS);
            conn->setAttribute(Connection::OSKEY_BUS, bus->stringValue());
            ObjectState* segment = srcOrDest->childByName(SOCKET_SEGMENT);
            conn->setAttribute(
                Connection::OSKEY_SEGMENT, segment->stringValue());
        }
 
    } else {
        socket->setAttribute(
            Socket::OSKEY_DIRECTION, Socket::OSVALUE_UNKNOWN);
    }
 
    return socket;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), ObjectState::setAttribute(), SOCKET_BUS, SOCKET_NAME, SOCKET_READS_FROM, SOCKET_SEGMENT, SOCKET_WRITES_TO, ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToMachineFormat().

Here is the call graph for this function:

socketToMDF()

ObjectState * ADFSerializer::socketToMDF ( const ObjectState *  socketState )

staticprivate

Creates a new ObjectState tree which matches one-to-one with MDF specs syntax.

The tree is created according to the given ObjectState tree created by Socket::saveState.

Parameters

socketState

Root node of the ObjectState tree created by Socket::saveState.

Returns

The newly created ObjectState tree.

Definition at line 543 of file ADFSerializer.cc.

                                                         {
 
    ObjectState* socket = new ObjectState(SOCKET);
    socket->setAttribute(
        SOCKET_NAME, socketState->stringAttribute(Socket::OSKEY_NAME));
 
    bool input;
    if (socketState->stringAttribute(Socket::OSKEY_DIRECTION) ==
        Socket::OSVALUE_INPUT) {
        input = true;
    } else if (socketState->stringAttribute(Socket::OSKEY_DIRECTION) ==
               Socket::OSVALUE_OUTPUT) {
        input = false;
    } else {
        return socket;
    }
 
    for (int i = 0; i < socketState->childCount(); i++) {
        ObjectState* child = socketState->child(i);
        ObjectState* conn;
        if (input) {
            conn = new ObjectState(SOCKET_READS_FROM);
        } else {
            conn = new ObjectState(SOCKET_WRITES_TO);
        }
        socket->addChild(conn);
        ObjectState* bus = new ObjectState(SOCKET_BUS);
        conn->addChild(bus);
        bus->setValue(child->stringAttribute(Connection::OSKEY_BUS));
 
        ObjectState* segment = new ObjectState(SOCKET_SEGMENT);
        conn->addChild(segment);
        if (child->hasAttribute(Connection::OSKEY_SEGMENT)) {
            segment->setValue(
                child->stringAttribute(Connection::OSKEY_SEGMENT));
        }
    }
 
    return socket;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), ObjectState::hasAttribute(), ObjectState::setAttribute(), ObjectState::setValue(), SOCKET, SOCKET_BUS, SOCKET_NAME, SOCKET_READS_FROM, SOCKET_SEGMENT, SOCKET_WRITES_TO, and ObjectState::stringAttribute().

Referenced by convertToMDFFormat().

Here is the call graph for this function:

writeMachine()

void ADFSerializer::writeMachine

(

const TTAMachine::Machine &

machine

)

Serializes the given machine to mdf file.

Parameters

machine

The machine to be serialized.

Exceptions

SerializerException

If an error occurs while serializing.

Definition at line 259 of file ADFSerializer.cc.

                                                  {
    ObjectState* machineState = machine.saveState();
    writeState(machineState);
    delete machineState;
}

References machine, TTAMachine::Machine::saveState(), and writeState().

Referenced by CompileTools::compileAsC(), CompileTools::compileAsLLVM(), TTAMachine::Machine::hash(), MDFDocument::OnSaveDocument(), DesignSpaceExplorer::schedule(), TDGen::writeBackendCode(), and TTAMachine::Machine::writeToADF().

Here is the call graph for this function:

writeState()

void ADFSerializer::writeState ( const ObjectState *  machineState )

virtual

Writes the given ObjectState tree created by Machine::saveState to the destination file.

Parameters

machineState

ObjectState tree created by Machine::saveState.

Exceptions

SerializerException

If an error occurs while serializing.

Reimplemented from XMLSerializer.

Definition at line 224 of file ADFSerializer.cc.

                                                         {
    ObjectState* converted = convertToMDFFormat(machineState);
    XMLSerializer::writeState(converted);
    delete converted;
}

References convertToMDFFormat(), and XMLSerializer::writeState().

Referenced by DSDBManager::addArchitecture(), DSDBManager::writeArchitectureToFile(), and writeMachine().

Here is the call graph for this function:

---

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

• ADFSerializer.hh
• ADFSerializer.cc