#include <ProcedureTransferTracker.hh>

Inheritance diagram for ProcedureTransferTracker:

Collaboration diagram for ProcedureTransferTracker:

Public Member Functions
	ProcedureTransferTracker (SimulatorFrontend &subject, ExecutionTrace &traceDB)

	ProcedureTransferTracker (SimulatorFrontend &subject)

virtual	~ProcedureTransferTracker ()

virtual void	handleEvent ()

virtual void	addProcedureTransfer (ClockCycleCount cycle, InstructionAddress address, InstructionAddress sourceAddress, bool isEntry)

Public Member Functions inherited from Listener
	Listener ()

virtual	~Listener ()

virtual void	handleEvent (int event)

Private Attributes
SimulatorFrontend &	subject_
	the tracked SimulatorFrontend instance More...

ExecutionTrace *	traceDB_
	the trace database to store the trace to More...

const TTAProgram::Instruction *	previousInstruction_
	the previously executed instruction More...

Detailed Description

Tracks procedure transfers in the simulated program.

Stores data of the transfer in trace database.

Definition at line 51 of file ProcedureTransferTracker.hh.

Constructor & Destructor Documentation

◆ ProcedureTransferTracker() [1/2]

ProcedureTransferTracker::ProcedureTransferTracker	(	SimulatorFrontend &	subject,
		ExecutionTrace &	traceDB
	)

Constructor for the default implementation of storing the transfers to a TraceDB.

Parameters

subject	The SimulationController which is observed.
traceDB	The Execution Trace Database instance in which the trace is stored. Expects that the database is open for writing.

Definition at line 59 of file ProcedureTransferTracker.cc.

                              : 
     Listener(), subject_(subject), traceDB_(&traceDB), 
     previousInstruction_(NULL) {
     subject.eventHandler().registerListener(
         SimulationEventHandler::SE_CYCLE_END, this);
 }

References SimulatorFrontend::eventHandler(), Informer::registerListener(), and SimulationEventHandler::SE_CYCLE_END.

Here is the call graph for this function:

◆ ProcedureTransferTracker() [2/2]

ProcedureTransferTracker::ProcedureTransferTracker ( SimulatorFrontend & subject )

Constructors for the derived implementations.

The implementation should override the addProcedureTransfer() to record the transfers as wished.

Definition at line 74 of file ProcedureTransferTracker.cc.

                                 : 
     Listener(), subject_(subject), traceDB_(NULL),
     previousInstruction_(NULL) {
     subject.eventHandler().registerListener(
         SimulationEventHandler::SE_CYCLE_END, this);
 }

References SimulatorFrontend::eventHandler(), Informer::registerListener(), and SimulationEventHandler::SE_CYCLE_END.

Here is the call graph for this function:

◆ ~ProcedureTransferTracker()

ProcedureTransferTracker::~ProcedureTransferTracker ( )

virtual

Destructor.

Definition at line 85 of file ProcedureTransferTracker.cc.

                                                     {
     subject_.eventHandler().unregisterListener(
         SimulationEventHandler::SE_CYCLE_END, this);
 }

References SimulatorFrontend::eventHandler(), SimulationEventHandler::SE_CYCLE_END, subject_, and Informer::unregisterListener().

Here is the call graph for this function:

Member Function Documentation

◆ addProcedureTransfer()

void ProcedureTransferTracker::addProcedureTransfer	(	ClockCycleCount	cycle,
		InstructionAddress	address,
		InstructionAddress	sourceAddress,
		bool	isEntry
	)

virtual

This function is called to record a procedure transfer (call or return).

The default implementation stores the transfer to a TraceDB.

Reimplemented in CallPathTracker.

Definition at line 161 of file ProcedureTransferTracker.cc.

                   {
  
     if (traceDB_ == NULL)
         return;
  
     try {
         traceDB_->addProcedureTransfer(
             cycle, address, sourceAddress, 
             isEntry? ExecutionTrace::PT_ENTRY : ExecutionTrace::PT_EXIT);
     } catch (const Exception& e) {
         debugLog("Error while writing TraceDB: " + e.errorMessage());
     }
 }

References ExecutionTrace::addProcedureTransfer(), debugLog, Exception::errorMessage(), ExecutionTrace::PT_ENTRY, ExecutionTrace::PT_EXIT, and traceDB_.

Referenced by handleEvent().

Here is the call graph for this function:

◆ handleEvent()

void ProcedureTransferTracker::handleEvent ( )

virtual

Stored procedure transfer data to execution database.

Last executed instruction is saved and its procedure is compared to the procedure of the current instruction. If they differ, a procedure transfer has happened and data of it is stored in trace database.

Reimplemented from Listener.

Definition at line 98 of file ProcedureTransferTracker.cc.

                                       {
  
     InstructionAddress lastExecutedInstrAddr = 
         subject_.lastExecutedInstruction();
     // the instruction that WAS executed in the current cycle (this handles
     // clock cycle *end* events)
     const TTAProgram::Instruction& currentInstruction =
         subject_.program().instructionAt(lastExecutedInstrAddr);
  
     if (!currentInstruction.isInProcedure() ||
         (previousInstruction_ != NULL && &(currentInstruction.parent()) == 
          &(previousInstruction_->parent()))) {
         // the instrution is not in a procedure (probably hand coded 
         // assembly program without procedure info), or there was no
         // procedure transfer
         previousInstruction_ = &currentInstruction;
         return;
     }
  
     bool entry = true;
     // the address of the call or the return
     InstructionAddress lastControlFlowInstructionAddress = 0;
     // in case this is the first instruction, consider this a procedure
     // entry (to the first procedure)
     if (previousInstruction_ != NULL) {
         // find the instruction which is responsible for the procedure 
         // change: it should be the instruction at the last executed
         // instruction at the source procedure minus the count of delay
         // slots
         lastControlFlowInstructionAddress = 
             previousInstruction_->address().location() - 
             subject_.machine().controlUnit()->delaySlots();
         const TTAProgram::Instruction& lastControlFlowInstruction =
             subject_.program().instructionAt(
                 lastControlFlowInstructionAddress);
  
         // check if the instruction contains a move to gcu.jump.
         // if there's no such a move, we'll assume it's a call
         for (int i = 0; i < lastControlFlowInstruction.moveCount(); ++i) {
         
             TTAProgram::Move& lastMove = lastControlFlowInstruction.move(i);
             if (dynamic_cast<TTAProgram::TerminalFUPort*>(
                 &lastMove.destination()) == 0) {
                 continue;
             }
             if (lastMove.destination().isOpcodeSetting() && lastMove.isJump()) {
                 entry = false;
                 break;
             }
         }
     }  
     previousInstruction_ = &currentInstruction;
     addProcedureTransfer(
         subject_.cycleCount(), lastExecutedInstrAddr, 
         lastControlFlowInstructionAddress, entry);
 }