SimProgramBuilder Class Reference

#include <SimProgramBuilder.hh>

Collaboration diagram for SimProgramBuilder:

Public Member Functions
	SimProgramBuilder ()
virtual	~SimProgramBuilder ()
InstructionMemory *	build (const TTAProgram::Program &prog, MachineState &state)

Private Member Functions
	SimProgramBuilder (const SimProgramBuilder &)
	Copying not allowed. More...
SimProgramBuilder &	operator= (const SimProgramBuilder &)
	Assignment not allowed. More...
StateData *	processBidirTerminal (const TTAProgram::Terminal &theTerminal, MachineState &state)
const ReadableState &	findGuardModel (const TTAMachine::Guard &guard, MachineState &state)
StateData *	processSourceTerminal (const TTAProgram::Terminal &theTerminal, MachineState &state)
ExecutableInstruction *	processInstruction (const TTAProgram::Instruction &instruction, MachineState &state)
ExecutableMove *	processMove (const TTAProgram::Move &move, MachineState &state)

Private Attributes
bool	sequentialProgram_

Detailed Description

Creates InstructionMemory out of Program Object Model.

Definition at line 62 of file SimProgramBuilder.hh.

Constructor & Destructor Documentation

SimProgramBuilder() [1/2]

SimProgramBuilder::SimProgramBuilder

(

)

Constructor.

Definition at line 90 of file SimProgramBuilder.cc.

                                     : 
    sequentialProgram_(false) {
}

~SimProgramBuilder()

SimProgramBuilder::~SimProgramBuilder ( )

virtual

Destructor.

Definition at line 97 of file SimProgramBuilder.cc.

                                      {
}

SimProgramBuilder() [2/2]

SimProgramBuilder::SimProgramBuilder ( const SimProgramBuilder &  )

private

Copying not allowed.

Member Function Documentation

build()

InstructionMemory * SimProgramBuilder::build	(	const TTAProgram::Program &	prog,
		MachineState &	state
	)

Builds the model of instruction memory ready to be simulated.

Parameters

prog	Program from which the contents of instruction memory is built.
state	The MachineState the program refers to.

Returns

The created instruction memory, owned by client.

Exceptions

IllegalProgram

If building fails for some reason. The exception message describes the reason. The message can be displayed in user interfaces as it's generated by SimulatorTextGenerator.

Definition at line 472 of file SimProgramBuilder.cc.

                                                                 {
    sequentialProgram_ = 
        (dynamic_cast<const UniversalMachine*>(
            &prog.targetProcessor()) != NULL);
    const Address& programStartAddress = prog.startAddress();
 
    InstructionMemory* memory = 
        new InstructionMemory(programStartAddress.location());
 
    const TTAProgram::Instruction* currentInstruction = NULL;
    try {
 
        for (int procIndex = 0; procIndex < prog.procedureCount(); 
             ++procIndex) {
            const Procedure& proc = prog.procedureAtIndex(procIndex);
            for (int instrIndex = 0; instrIndex < proc.instructionCount(); 
                 ++instrIndex) {
                currentInstruction =
                    &proc.instructionAtIndex(instrIndex);
                ExecutableInstruction* processedInstruction =
                    processInstruction(*currentInstruction, state);
 
                if (currentInstruction->size() > 0) {
                    memory->addExecutableInstruction(
                        currentInstruction->address().location(),
                        processedInstruction);
                } else {
                    memory->addImplicitExecutableInstruction(
                        currentInstruction->address().location(),
                        processedInstruction);
                }
            }
        }
    } catch (const Exception& e) {
        throw IllegalProgram(
            __FILE__, __LINE__, __func__,
            (boost::format("Error while processing instruction %d "
                           "(with moves %s): %s")
             % currentInstruction->address().location()
             % POMDisassembler::disassemble(*currentInstruction)
             % e.errorMessage()).str());
    }
 
    return memory;
}

References __func__, InstructionMemory::addExecutableInstruction(), InstructionMemory::addImplicitExecutableInstruction(), TTAProgram::Instruction::address(), POMDisassembler::disassemble(), Exception::errorMessage(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Address::location(), TTAProgram::Program::procedureAtIndex(), TTAProgram::Program::procedureCount(), processInstruction(), sequentialProgram_, TTAProgram::Instruction::size(), TTAProgram::Program::startAddress(), and TTAProgram::Program::targetProcessor().

Referenced by SimulationController::SimulationController().

Here is the call graph for this function:

findGuardModel()

const ReadableState & SimProgramBuilder::findGuardModel ( const TTAMachine::Guard &  guard, MachineState &  state  )

private

Helper method for finding the state object the given guard targets.

Parameters

guard	The guard object from machine object model.
state	The machine state model.

Returns

The state object represeting the current value of the guard.

Exceptions

IllegalProgram

In case a state model for given guard cannot be found.

Definition at line 231 of file SimProgramBuilder.cc.

                                                       {
    try {
        GuardState& guardModel = state.guardState(guard);
        if (&guardModel != &NullGuardState::instance()) 
            return guardModel;
    } catch (const Exception& e) {
    }
    
    throw IllegalProgram(
        __FILE__, __LINE__, __func__, 
        "Program references an illegal guard.");
 
    // should never return from here
    return NullGuardState::instance();
}

References __func__, MachineState::guardState(), and NullGuardState::instance().

Referenced by processMove().

Here is the call graph for this function:

operator=()

SimProgramBuilder& SimProgramBuilder::operator= ( const SimProgramBuilder &  )

private

Assignment not allowed.

processBidirTerminal()

StateData * SimProgramBuilder::processBidirTerminal ( const TTAProgram::Terminal &  theTerminal, MachineState &  state  )

private

Helper method for processing such terminals that can be both source and destination in the move.

Parameters

theTerminal	The terminal to process.
state	MachineState to fetch the state objects from.

Returns

The StateData object created from the terminal.

Exceptions

IllegalProgram

When the terminal is referring to illegal machine state or the terminal itself is illegal.

Definition at line 111 of file SimProgramBuilder.cc.

                                                      {
    try {
        if (theTerminal.isGPR()) {
            
            RegisterFileState& unit = state.registerFileState(
                theTerminal.registerFile().name());
            if (&unit == &NullRegisterFileState::instance()) {
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, 
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_PROGRAM_RF_STATE_NOT_FOUND).str());
            }
            return &unit.registerState(theTerminal.index());
            
        } else if (theTerminal.isFUPort()) {
            
            const BaseFUPort* thePort = 
                dynamic_cast<const BaseFUPort*>(&theTerminal.port());
 
            if (thePort == NULL)
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, 
                    "Could not find the FU port.");
 
            std::string operationString = "";
            // if this is an opcode-setting port, find the
            // OpcodeSettingVirtualInputPort instead of a real port
 
            if (thePort->isOpcodeSetting()) {
                
                if (!theTerminal.isOpcodeSetting()) {
                    throw IllegalProgram(
                        __FILE__, __LINE__, __func__, 
                        SimulatorToolbox::textGenerator().text(
                            Texts::TXT_ILLEGAL_PROGRAM_OPCODE_NOT_FOUND).
                        str());
                }
                operationString = 
                    StringTools::stringToLower(
                        std::string(".") + theTerminal.operation().name());
            }
 
            PortState& port = state.portState(
                thePort->name() + operationString, 
                theTerminal.port().parentUnit()->name());
 
            if (&port == &NullPortState::instance()) {
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, 
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_PROGRAM_PORT_STATE_NOT_FOUND).
                    str());
            }
            
            return &port;
 
        } else {
            abortWithError("Illegal terminal!");
        }
    } catch (const OutOfRange& e) {
        abortWithError(e.errorMessage());
    } catch (const WrongSubclass&) {
        abortWithError("Wrong sub class!");
    }
 
    std::string errorMsg = 
        SimulatorToolbox::textGenerator().text(
        Texts::TXT_ILLEGAL_PROGRAM_UNKNOWN_MOVE_TERMINAL_TYPE).str();
    throw IllegalProgram(__FILE__, __LINE__, __func__, errorMsg);
    return NULL;
}

References __func__, abortWithError, Exception::errorMessage(), TTAProgram::Terminal::index(), NullPortState::instance(), NullRegisterFileState::instance(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAMachine::BaseFUPort::isOpcodeSetting(), TTAProgram::Terminal::isOpcodeSetting(), TTAMachine::Port::name(), TTAMachine::Component::name(), Operation::name(), TTAProgram::Terminal::operation(), TTAMachine::Port::parentUnit(), TTAProgram::Terminal::port(), MachineState::portState(), TTAProgram::Terminal::registerFile(), MachineState::registerFileState(), RegisterFileState::registerState(), StringTools::stringToLower(), Texts::TextGenerator::text(), SimulatorToolbox::textGenerator(), Texts::TXT_ILLEGAL_PROGRAM_OPCODE_NOT_FOUND, Texts::TXT_ILLEGAL_PROGRAM_PORT_STATE_NOT_FOUND, Texts::TXT_ILLEGAL_PROGRAM_RF_STATE_NOT_FOUND, and Texts::TXT_ILLEGAL_PROGRAM_UNKNOWN_MOVE_TERMINAL_TYPE.

Referenced by processMove(), and processSourceTerminal().

Here is the call graph for this function:

processInstruction()

ExecutableInstruction * SimProgramBuilder::processInstruction ( const TTAProgram::Instruction &  instruction, MachineState &  state  )

private

Processes a POM Instruction and produces an ExecutableInstruction.

Parameters

instruction	The instruction to process.
state	The MachineState the program refers to.

Returns

The processed instruction.

Exceptions

IllegalProgram

If the input instruction was illegal.

Definition at line 402 of file SimProgramBuilder.cc.

                                                         {
    ExecutableInstruction* processedInstruction = new ExecutableInstruction();
 
    // process long immediates
    for (int i = 0; i < instruction.immediateCount(); ++i) {
        assert(instruction.immediate(i).destination().isImmediateRegister());
 
        // first fetch the LongImmediateUnitState, then fetch the
        // LongImmediateRegisterState from it, because there is no such 
        // object in MOM as LongImmediateRegister, nor any single registers
        LongImmediateRegisterState* destination = NULL;
        try {
            LongImmediateUnitState& targetUnit = state.longImmediateUnitState(
                instruction.immediate(i).destination().immediateUnit().name());
 
            destination = &targetUnit.immediateRegister(
                instruction.immediate(i).destination().index());
 
            if (&targetUnit == &NullLongImmediateUnitState::instance()) {
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, 
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND).str());
            }
        } catch (const IllegalParameters&) {
            throw IllegalProgram(
                __FILE__, __LINE__, __func__, 
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND).str());
        } catch (const OutOfRange&) {
            throw IllegalProgram(
                __FILE__, __LINE__, __func__, 
                SimulatorToolbox::textGenerator().text(
                    Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND).str());
        }
 
        processedInstruction->addLongImmediateUpdateAction(
            new LongImmUpdateAction(instruction.immediate(i).value().value(),
                                    *destination));
    }
    
    // process all the moves in the instruction
    for (int j = 0; j < instruction.moveCount(); ++j) {
        try {
            processedInstruction->addExecutableMove(
                processMove(instruction.move(j), state));
        } catch (const IllegalProgram& e) {
            IllegalProgram ip(
                e.fileName(), e.lineNum(), e.procedureName(),
                e.errorMessage() + " Illegal move: " + 
                POMDisassembler::disassemble(instruction.move(j)));
            throw ip;
        }
    }
    return processedInstruction;
}

References __func__, ExecutableInstruction::addExecutableMove(), ExecutableInstruction::addLongImmediateUpdateAction(), assert, TTAProgram::Immediate::destination(), POMDisassembler::disassemble(), Exception::errorMessage(), Exception::fileName(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), LongImmediateUnitState::immediateRegister(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), NullLongImmediateUnitState::instance(), TTAProgram::Terminal::isImmediateRegister(), Exception::lineNum(), MachineState::longImmediateUnitState(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAMachine::Component::name(), Exception::procedureName(), processMove(), SimulatorToolbox::textGenerator(), Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND, TTAProgram::TerminalImmediate::value(), and TTAProgram::Immediate::value().

Referenced by build().

Here is the call graph for this function:

processMove()

ExecutableMove * SimProgramBuilder::processMove ( const TTAProgram::Move &  move, MachineState &  state  )

private

Processes a POM Move and produces an ExecutableMove.

Parameters

move	The move to process.
state	The MachineState the program refers to.

Returns

The processed move.

Exceptions

IllegalProgram

If the input move was illegal.

Definition at line 257 of file SimProgramBuilder.cc.

                                                                    {
    ReadableState* source = NULL;
    InlineImmediateValue* immediateSource = NULL;
 
    if (move.source().isImmediate()) {
        // extend the immediate so we don't have to extend it
        // during runtime every time the move is simulated
        immediateSource = new InlineImmediateValue(move.bus().width());
 
        if (move.isControlFlowMove()) {
            int targetWidth = move.destination().port().width();
            if (!move.bus().signExtends()) {
                ULongWord immediate =
                move.source().value().uLongWordValue();
                if (targetWidth < MathTools::requiredBits(immediate)) {
                    TCEString errorMsg =
                        (boost::format(
                             "Immediate of jump '%s' gets clipped due to the target "
                             "port being too narrow. Wrong execution would occur.")
                         % move.toString()).str();
                    throw IllegalProgram(
                        __FILE__, __LINE__, __func__, errorMsg);
                }
            } else {
                SLongWord immediate =
                move.source().value().sLongWordValue();
                if (targetWidth < MathTools::requiredBitsSigned(immediate)) {
                    TCEString errorMsg =
                        (boost::format(
                             "Immediate of jump '%s' gets clipped due to the target "
                             "port being too narrow. Wrong execution would occur.")
                         % move.toString()).str();
                    throw IllegalProgram(
                        __FILE__, __LINE__, __func__, errorMsg);
                }
            }
        }
 
        SimValue val(move.bus().width());
        val = move.source().value();
        if (move.bus().signExtends()) {
            val.signExtendTo(move.bus().immediateWidth());
        } else {
            val.zeroExtendTo(move.bus().immediateWidth());
        }
        immediateSource->setValue(val);
    }  else {
        source = processSourceTerminal(move.source(), state);
    }
 
    BusState& bus = state.busState(move.bus().name());
    if (&bus == &NullBusState::instance()) {
        throw IllegalProgram(
        __FILE__, __LINE__, __func__,
        SimulatorToolbox::textGenerator().text(
            Texts::TXT_ILLEGAL_PROGRAM_BUS_STATE_NOT_FOUND).str());
    }
 
    WritableState& destination =
        *processBidirTerminal(move.destination(), state);
 
    // in case this is a sequential move, or a move that executes a
    // control flow operation with immediate or control unit port source (RA)
    // it does not utilize any bus
    bool buslessMove = sequentialProgram_;
    if (!GCU_OPERATION_MOVES_VISIBLE_IN_BUS && !sequentialProgram_) {
        if (move.destination().isFUPort()) {
            if (dynamic_cast<const TTAMachine::ControlUnit*>(
                    &move.destination().functionUnit())) {
                if (move.source().isImmediate() ||
                    (move.source().isFUPort() &&
                     dynamic_cast<const TTAMachine::ControlUnit*>(
                         &move.source().functionUnit()) != NULL)) {
                    buslessMove = true;
                }
            }
        }
    }
 
    // handle guards
    if (move.isUnconditional()) {
        // create a guardless execmove
        if (move.source().isImmediate()) {
            assert(immediateSource != NULL);
            if (buslessMove) {
                return new BuslessExecutableMove(immediateSource, destination);
            } else {
                return new ExecutableMove(immediateSource, bus, destination);
            }
        } else {
            assert(source != NULL);
            if (buslessMove) {
                return new BuslessExecutableMove(*source, destination);
            } else {
                return new ExecutableMove(*source, bus, destination);
            }
        }
    } else {
        // create a guarded move
        MoveGuard& guard = move.guard();
 
        if (move.source().isImmediate()) {
            assert(immediateSource != NULL);
            if (buslessMove) {
                return new BuslessExecutableMove(
                    immediateSource, destination,
                    findGuardModel(guard.guard(), state),
                    guard.guard().isInverted());
            } else {
                return new ExecutableMove(
                    immediateSource, bus, destination,
                    findGuardModel(guard.guard(), state),
                    guard.guard().isInverted());
            }
        } else {
            assert(source != NULL);
            if (buslessMove) {
                return new BuslessExecutableMove(
                    *source, destination,
                    findGuardModel(guard.guard(), state),
                    guard.guard().isInverted());
            } else {
                return new ExecutableMove(
                    *source, bus, destination,
                    findGuardModel(guard.guard(), state),
                    guard.guard().isInverted());
            }
        }
    }
 
    // should never end up here
    assert(false);
 
    return NULL;
}

References __func__, assert, TTAProgram::Move::bus(), MachineState::busState(), TTAProgram::Move::destination(), findGuardModel(), TTAProgram::Terminal::functionUnit(), GCU_OPERATION_MOVES_VISIBLE_IN_BUS, TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::immediateWidth(), NullBusState::instance(), TTAProgram::Move::isControlFlowMove(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isImmediate(), TTAMachine::Guard::isInverted(), TTAProgram::Move::isUnconditional(), TTAMachine::Component::name(), TTAProgram::Terminal::port(), processBidirTerminal(), processSourceTerminal(), MathTools::requiredBits(), MathTools::requiredBitsSigned(), sequentialProgram_, RegisterState::setValue(), TTAMachine::Bus::signExtends(), SimValue::signExtendTo(), SimValue::sLongWordValue(), TTAProgram::Move::source(), SimulatorToolbox::textGenerator(), TTAProgram::Move::toString(), Texts::TXT_ILLEGAL_PROGRAM_BUS_STATE_NOT_FOUND, SimValue::uLongWordValue(), TTAProgram::Terminal::value(), TTAMachine::Port::width(), TTAMachine::Bus::width(), and SimValue::zeroExtendTo().

Referenced by processInstruction().

Here is the call graph for this function:

processSourceTerminal()

StateData * SimProgramBuilder::processSourceTerminal ( const TTAProgram::Terminal &  theTerminal, MachineState &  state  )

private

Helper method for processing source terminals.

Parameters

theTerminal	The terminal to process.
state	MachineState to fetch the state objects from.

Returns

The StateData object created from the terminal.

Exceptions

IllegalProgram

When the terminal is referring to illegal machine state or the terminal itself is illegal.

Definition at line 194 of file SimProgramBuilder.cc.

                                                      {
    try {
        if (theTerminal.isImmediateRegister()) {
            
            LongImmediateUnitState& unit = state.longImmediateUnitState(
                theTerminal.immediateUnit().name());
            if (&unit == &NullLongImmediateUnitState::instance()) {
                throw IllegalProgram(
                    __FILE__, __LINE__, __func__, 
                    SimulatorToolbox::textGenerator().text(
                        Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND).str());
            }
            return &unit.immediateRegister(theTerminal.index());
        } else {
            return processBidirTerminal(theTerminal, state);
        }
    } catch (const OutOfRange&) {
    } catch (const WrongSubclass&) {
    }
    throw IllegalProgram(
        __FILE__, __LINE__, __func__, 
        SimulatorToolbox::textGenerator().text(
            Texts::TXT_ILLEGAL_PROGRAM_UNKNOWN_MOVE_TERMINAL_TYPE).str());
    return NULL;
}

References __func__, LongImmediateUnitState::immediateRegister(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), NullLongImmediateUnitState::instance(), TTAProgram::Terminal::isImmediateRegister(), MachineState::longImmediateUnitState(), TTAMachine::Component::name(), processBidirTerminal(), SimulatorToolbox::textGenerator(), Texts::TXT_ILLEGAL_PROGRAM_IU_STATE_NOT_FOUND, and Texts::TXT_ILLEGAL_PROGRAM_UNKNOWN_MOVE_TERMINAL_TYPE.

Referenced by processMove().

Here is the call graph for this function:

Member Data Documentation

sequentialProgram_

bool SimProgramBuilder::sequentialProgram_

private

Definition at line 92 of file SimProgramBuilder.hh.

Referenced by build(), and processMove().

---

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

• SimProgramBuilder.hh
• SimProgramBuilder.cc