#include "UniversalMachine.hh"
#include "Program.hh"
#include "Procedure.hh"
#include "Instruction.hh"
#include "Move.hh"
#include "MoveGuard.hh"
#include "Guard.hh"
#include "Terminal.hh"
#include "TerminalImmediate.hh"
#include "TerminalRegister.hh"
#include "SimValue.hh"
#include "OperationPool.hh"
#include "Application.hh"
#include "UniversalFunctionUnit.hh"
#include "UnboundedRegisterFile.hh"
#include "SmartHWOperation.hh"
#include "FUPort.hh"
#include "TerminalFUPort.hh"
#include "BaseFUPort.hh"
#include "Port.hh"
#include "SpecialRegisterPort.hh"
#include "RegisterFile.hh"
#include "FunctionUnit.hh"
#include "ControlUnit.hh"
#include "AssocTools.hh"
#include "StringTools.hh"
#include "Conversion.hh"

Include dependency graph for POMGenMacros.hh:

Macros
#define	PRINTOUT(STUFF)
	define this to get the programs printed to stdout while they are contructed

#define	REG(RFNAME, REGNUM)

#define	IREG(REGNUM) REG(r, REGNUM)

#define	PORT(FUNAME, PORTNAME)

#define	OPORT(FUNAME, PORTNAME, OPERATION)

#define	OPERAND(OPERATION, OPERAND_INDEX) OPORT(OPERATION, OPERAND_INDEX, OPERATION)

#define	IMM(WIDTH, VALUE)

#define	CONTROL_OPERAND(OPERATION, OPNUM)

#define	BOOL()

#define	BOOLGUARD()

#define	INVBOOLGUARD()

#define	RA()

#define	IMM32(VALUE) IMM(32, VALUE)

#define	INSTRUCTION(ADD_MOVES)

#define	MOVE_TEMPLATE(SRC, DST, CONSTRUCT_MOVE)

#define	BASIC_MOVE_CONSTRUCTION tempMove = std::make_shared<Move>(src__, dst__, *bus__)

#define	MOVE(SRC, DST) MOVE_TEMPLATE(SRC, DST, BASIC_MOVE_CONSTRUCTION);

#define	NOP PRINTOUT("nop "); moveCounter__++;

#define	LABEL(LABEL_NAME) iaddress_##LABEL_NAME

#define	SET_LABEL(LABEL_NAME)

#define	SET_IP(VALUE) currentIP__ = VALUE

#define	SET_IP_INCREMENT(COUNT) incrementOfIP__ = COUNT

#define	GUARDED_MOVE_CONSTRUCTION(ADFGUARD)

#define	GMOVE(SRC, DST, GUARD) MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GUARD));

#define	CREATE_PROGRAM(PROGRAM, MACHINE)

#define	CREATE_PROCEDURE(PROCNAME)

#define	END_PROGRAM

Functions
void	null__ ()

TTAMachine::RegisterFile &	findRegisterFile (const TTAMachine::Machine &machine, std::string name)

TTAMachine::FunctionUnit &	findFunctionUnit (const TTAMachine::Machine &machine, std::string name)

TTAProgram::TerminalFUPort *	createTerminalFUPort (const TTAMachine::Machine &machine, std::string fuName, std::string pName, std::string opName)

TTAMachine::Port &	findFUPort (const TTAMachine::Machine &machine, std::string fuName, std::string portName)

SimValue &	tempSimValue (unsigned int bitWidth, SIntWord intValue)

TTAMachine::Bus &	findBus (const TTAMachine::Machine &machine, std::string busName)

TTAMachine::RegisterFile &	findBooleanRegisterFile (const TTAMachine::Machine &machine)

TTAMachine::Guard &	findBooleanGuard (const TTAMachine::Machine &machine, bool isInverted)

Variables
SimValue *	temporary = NULL

Detailed Description

A macro set and helper functions for implementing the macros to make creating of Program Object Models for unit tests manually easy.

Author: Pekka Jääskeläinen 2005 (pjaaskel-no.spam-cs.tut.fi)

Definition in file POMGenMacros.hh.

Macro Definition Documentation

◆ BASIC_MOVE_CONSTRUCTION

#define BASIC_MOVE_CONSTRUCTION tempMove = std::make_shared<Move>(src__, dst__, *bus__)

Creates a basic move without any guards.

Definition at line 446 of file POMGenMacros.hh.

◆ BOOL

#define BOOL ( )

Value:

    new TerminalRegister(\
           *findBooleanRegisterFile(machine__).port(0), 0);\
    PRINTOUT("bool")

Creates a terminal pointing to the boolean register.

Definition at line 371 of file POMGenMacros.hh.

{\
    Instruction* tempInstruction__ = new Instruction(); \
    int moveCounter__ = 1; \
    PRINTOUT("\t" << currentIP__ << ": ");\
    ADD_MOVES; \
    PRINTOUT("\n");\
    proc->add(tempInstruction__); \
} currentIP__ += incrementOfIP__
 
/**
 * A helper macro to create different types of moves.
 *
 * @param SRC The source terminal.
 * @param DST The destination terminal.
 * @param MOVE_CONSTRUCTOR A constructor of the move to create.
 */
#define MOVE_TEMPLATE(SRC, DST, CONSTRUCT_MOVE) \
{\
    Terminal* src__ = SRC;\
    PRINTOUT(" -> "); \
    Terminal* dst__ = DST;\
    PRINTOUT(" "); \
    Bus* bus__ = &findBus(\
        machine__, std::string("bus") + Conversion::toString(moveCounter__));\
    std::shared_ptr<Move> tempMove = nullptr;                                          \
    CONSTRUCT_MOVE;\
    tempInstruction__->addMove(tempMove);\
} moveCounter__++;
 
/**
 * Creates a basic move without any guards.
 */
#define BASIC_MOVE_CONSTRUCTION tempMove = std::make_shared<Move>(src__, dst__, *bus__)
 
/**
 * Creates a basic move and adds it to the instruction this macro is 
 * invoked in.
 *
 * Expects that the bus names of the machine are named by appending the
 * index of the bus to the word 'bus', i.e., 'bus1', 'bus2', etc.
 *
 * @param SRC The source terminal.
 * @param DST The destination terminal.
 */
#define MOVE(SRC, DST) MOVE_TEMPLATE(SRC, DST, BASIC_MOVE_CONSTRUCTION);
 
/**
 * A no-operation move.
 *
 * Just skips the move slot by incrementing the move counter.
 */
#define NOP PRINTOUT("nop "); moveCounter__++;
 
/**
 * Gets the variable connected to a label.
 *
 * Using LABEL and SET_LABEL macros one can make implementing backward
 * jumps easier.
 * 
 * @param LABEL_NAME The name of the label to refer to.
 */
#define LABEL(LABEL_NAME) iaddress_##LABEL_NAME
 
/**
 * Sets a label at the current instruction pointer position.
 *
 * Using LABEL and SET_LABEL macros one can make implementing backward
 * jumps easier.
 * 
 * @param LABEL_NAME The name of the label to refer to.
 */
#define SET_LABEL(LABEL_NAME) \
    PRINTOUT(#LABEL_NAME ":\n");\
    unsigned int LABEL(LABEL_NAME) = currentIP__; \
    LABEL(LABEL_NAME) = currentIP__;
 
/**
 * Forces a new value to the instruction pointer.
 *
 * @param VALUE The new value to assign to the instruction pointer counter.
 */
#define SET_IP(VALUE) currentIP__ = VALUE
 
/**
 * Sets the amount how much instruction pointer should be incremented after
 * adding an instruction.
 *
 * @param COUNT The increment.
 */
#define SET_IP_INCREMENT(COUNT) incrementOfIP__ = COUNT
 
/**
 * Creation of guarded move.
 *
 * @param TERMINAL The terminal the guard should watch.
 * @param INVERT Is the guard inverted? true if it is.
 
#define GUARDED_MOVE_CONSTRUCTION(TERMINAL, INVERT) \
    PRINTOUT(" || only if ");\
    Terminal* term__ = TERMINAL;\
    PRINTOUT(" != " #INVERT); \
    PRINTOUT(" ||"); \
    MoveGuard* guard__ = new MoveGuard(term__, INVERT); \
    tempMove = new Move(src__, dst__, *bus__, guard__); 
 */
 
#define GUARDED_MOVE_CONSTRUCTION(ADFGUARD) \
    TTAMachine::Guard &adfGuard__ = ADFGUARD; \
    MoveGuard* guard__ = new MoveGuard(adfGuard__); \
    tempMove = std::make_shared<Move>(src__, dst__, *bus__, guard__);
 
  
/**
 * Creates a guarded move and adds it to the instruction this macro is 
 * invoked in.
 *
 * Non-inverted version. 
 *
 * @param SRC The source terminal.
 * @param DST The destination terminal.
 * @param GTERM The termimal that is watched by this guard.
 #define GMOVE(SRC, DST, GTERM) \
 MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GTERM, false));
 */
 
#define GMOVE(SRC, DST, GUARD) \
    MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GUARD));
 
/**
 * Creates a guarded move and adds it to the instruction this macro is 
 * invoked in.
 *
 * Inverted version.s
 *
 * @param SRC The source terminal.
 * @param DST The destination terminal.
 * @param GTERM The termimal that is watched by this guard.
 #define IGMOVE(SRC, DST, GTERM) \
 MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GTERM, true));
*/
 
/**
 * Initializes the POM generator macros. 
 *
 * This should be stated before using the above macros.
 *
 * @PROGRAM The name of the program.
 * @MACHINE The target processor of the program.
 */
#define CREATE_PROGRAM(PROGRAM, MACHINE) \
\
    Application::initialize(); \
    OperationPool operationPool; \
    unsigned int currentIP__ = 0; \
    currentIP__ = 0; \
    unsigned int incrementOfIP__ = 1; \
    incrementOfIP__ = 1; \
    Procedure* proc = NULL;\
    const AddressSpace& programSpace__ = \
        *MACHINE.controlUnit()->addressSpace();\
    Program PROGRAM(programSpace__);\
    Program& program__ = PROGRAM; \
    const Machine& machine__ = MACHINE;\
    PRINTOUT("\n# program '" #PROGRAM "':\n")
 
/**
 * Creates a new procedure to add instructions to.
 *
 * Sets a label to the creation position.
 */
#define CREATE_PROCEDURE(PROCNAME) \
    SET_LABEL(PROCNAME); \
    Procedure* PROCNAME = \
        new Procedure("proc_"#PROCNAME, programSpace__, LABEL(PROCNAME));\
    program__.addProcedure(PROCNAME);\
    proc = PROCNAME
 
/**
 * Frees the resources allocated by the POM generator macros.
 *
 * Currently does basically nothing. Code is there just to avoid compiler
 * warnings/errors.
 */
#define END_PROGRAM \
    int foooooO__ = 1; foooooO__++;\
    PRINTOUT("\n# program ends\n")
 
#endif

◆ BOOLGUARD

#define BOOLGUARD ( )

Value:

findBooleanGuard(machine__, false);\

PRINTOUT("boolguard")

findBooleanGuard

TTAMachine::Guard & findBooleanGuard(const TTAMachine::Machine &machine, bool isInverted)

Definition POMGenMacros.hh:343

Returns RegisterGuard pointing to boolean register

Definition at line 379 of file POMGenMacros.hh.

◆ CONTROL_OPERAND

#define CONTROL_OPERAND	(	OPERATION,
		OPNUM
	)

Value:

    new TerminalFUPort( \
        *machine__.controlUnit()->operation(#OPERATION), \
        OPNUM);\
    PRINTOUT(#OPERATION "." #OPNUM)

Creates a TerminalFUPort that writes to the GCU operand port, thus triggering a control flow operation.

Parameters

OPERATION	The name of the operation to trigger.
OPNUM	The operand number.

Definition at line 297 of file POMGenMacros.hh.

◆ CREATE_PROCEDURE

#define CREATE_PROCEDURE ( PROCNAME )

Value:

    SET_LABEL(PROCNAME); \
    Procedure* PROCNAME = \
        new Procedure("proc_"#PROCNAME, programSpace__, LABEL(PROCNAME));\
    program__.addProcedure(PROCNAME);\
    proc = PROCNAME

Creates a new procedure to add instructions to.

Sets a label to the creation position.

Definition at line 584 of file POMGenMacros.hh.

◆ CREATE_PROGRAM

#define CREATE_PROGRAM	(	PROGRAM,
		MACHINE
	)

Value:

\
    Application::initialize(); \
    OperationPool operationPool; \
    unsigned int currentIP__ = 0; \
    currentIP__ = 0; \
    unsigned int incrementOfIP__ = 1; \
    incrementOfIP__ = 1; \
    Procedure* proc = NULL;\
    const AddressSpace& programSpace__ = \
        *MACHINE.controlUnit()->addressSpace();\
    Program PROGRAM(programSpace__);\
    Program& program__ = PROGRAM; \
    const Machine& machine__ = MACHINE;\
    PRINTOUT("\n# program '" #PROGRAM "':\n")

Creates a guarded move and adds it to the instruction this macro is invoked in.

Inverted version.s

Parameters

SRC	The source terminal.
DST	The destination terminal.
GTERM	The termimal that is watched by this guard. #define IGMOVE(SRC, DST, GTERM) \ MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GTERM, true)); Initializes the POM generator macros.

This should be stated before using the above macros.

@PROGRAM The name of the program. @MACHINE The target processor of the program.

Definition at line 563 of file POMGenMacros.hh.

577 :\n")

◆ END_PROGRAM

#define END_PROGRAM

Value:

int foooooO__ = 1; foooooO__++;\

PRINTOUT("\n# program ends\n")

Frees the resources allocated by the POM generator macros.

Currently does basically nothing. Code is there just to avoid compiler warnings/errors.

Definition at line 597 of file POMGenMacros.hh.

◆ GMOVE

#define GMOVE	(	SRC,
		DST,
		GUARD
	)	MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GUARD));

Creates a guarded move and adds it to the instruction this macro is invoked in.

Non-inverted version.

Parameters

SRC	The source terminal.
DST	The destination terminal.
GTERM	The termimal that is watched by this guard. #define GMOVE(SRC, DST, GTERM) \ MOVE_TEMPLATE(SRC, DST, GUARDED_MOVE_CONSTRUCTION(GTERM, false));

Definition at line 539 of file POMGenMacros.hh.

◆ GUARDED_MOVE_CONSTRUCTION

#define GUARDED_MOVE_CONSTRUCTION ( ADFGUARD )

Value:

    TTAMachine::Guard &adfGuard__ = ADFGUARD; \
    MoveGuard* guard__ = new MoveGuard(adfGuard__); \
    tempMove = std::make_shared<Move>(src__, dst__, *bus__, guard__);

Creation of guarded move.

Parameters

TERMINAL	The terminal the guard should watch.
INVERT	Is the guard inverted? true if it is.

#define GUARDED_MOVE_CONSTRUCTION(TERMINAL, INVERT) \ PRINTOUT(" || only if ");\ Terminal* term__ = TERMINAL;\ PRINTOUT(" != " #INVERT); \ PRINTOUT(" ||"); \ MoveGuard* guard__ = new MoveGuard(term__, INVERT); \ tempMove = new Move(src__, dst__, *bus__, guard__);

Definition at line 520 of file POMGenMacros.hh.

◆ IMM

#define IMM	(	WIDTH,
		VALUE
	)

Value:

new TerminalImmediate(tempSimValue(WIDTH, VALUE)); \

PRINTOUT("#" #VALUE)

WIDTH

const string WIDTH

Definition MifImageWriter.cc:21

tempSimValue

SimValue & tempSimValue(unsigned int bitWidth, SIntWord intValue)

Definition POMGenMacros.hh:252

Creates a TerminalImmediate by width and value.

Expects the creator to manage deallocation.

Parameters

WIDTH	The bit width of the value.
VALUE	The value of the immediate.

Definition at line 286 of file POMGenMacros.hh.

◆ IMM32

#define IMM32 ( VALUE ) IMM(32, VALUE)

A shortcut which creates a 32 bit TerminalImmediate.

Parameters

VALUE The value of the immediate.

Definition at line 405 of file POMGenMacros.hh.

◆ INSTRUCTION

#define INSTRUCTION ( ADD_MOVES )

Value:

{\
    Instruction* tempInstruction__ = new Instruction(); \
    int moveCounter__ = 1; \
    PRINTOUT("\t" << currentIP__ << ": ");\
    ADD_MOVES; \
    PRINTOUT("\n");\
    proc->add(tempInstruction__); \
} currentIP__ += incrementOfIP__

Creates an instruction and adds it to a procedure.

Parameters

ADD_MOVES A (list of) move creation statement(s).

Definition at line 413 of file POMGenMacros.hh.

{\
    Instruction* tempInstruction__ = new Instruction(); \
    int moveCounter__ = 1; \
    PRINTOUT("\t" << currentIP__ << ": ");\
    ADD_MOVES; \
    PRINTOUT("\n");\
    proc->add(tempInstruction__); \
} currentIP__ += incrementOfIP__

◆ INVBOOLGUARD

#define INVBOOLGUARD ( )

Value:

findBooleanGuard(machine__, true);\

PRINTOUT("invboolguard")

Returns Inverted RegisterGuard pointing to boolean register

Definition at line 386 of file POMGenMacros.hh.

◆ IREG

#define IREG ( REGNUM ) REG(r, REGNUM)

Shortcut to an integer register in sequential code.

Parameters

REGNUM The integer register index.

Definition at line 133 of file POMGenMacros.hh.

◆ LABEL

#define LABEL ( LABEL_NAME ) iaddress_##LABEL_NAME

Gets the variable connected to a label.

Using LABEL and SET_LABEL macros one can make implementing backward jumps easier.

Parameters

LABEL_NAME The name of the label to refer to.

Definition at line 475 of file POMGenMacros.hh.

◆ MOVE

#define MOVE	(	SRC,
		DST
	)	MOVE_TEMPLATE(SRC, DST, BASIC_MOVE_CONSTRUCTION);

Creates a basic move and adds it to the instruction this macro is invoked in.

Expects that the bus names of the machine are named by appending the index of the bus to the word 'bus', i.e., 'bus1', 'bus2', etc.

Parameters

SRC	The source terminal.
DST	The destination terminal.

Definition at line 458 of file POMGenMacros.hh.

◆ MOVE_TEMPLATE

#define MOVE_TEMPLATE	(	SRC,
		DST,
		CONSTRUCT_MOVE
	)

Value:

{\
    Terminal* src__ = SRC;\
    PRINTOUT(" -> "); \
    Terminal* dst__ = DST;\
    PRINTOUT(" "); \
    Bus* bus__ = &findBus(\
        machine__, std::string("bus") + Conversion::toString(moveCounter__));\
    std::shared_ptr<Move> tempMove = nullptr;                                          \
    CONSTRUCT_MOVE;\
    tempInstruction__->addMove(tempMove);\
} moveCounter__++;

A helper macro to create different types of moves.

Parameters

SRC	The source terminal.
DST	The destination terminal.
MOVE_CONSTRUCTOR	A constructor of the move to create.

Definition at line 430 of file POMGenMacros.hh.

{\
    Terminal* src__ = SRC;\
    PRINTOUT(" -> "); \
    Terminal* dst__ = DST;\
    PRINTOUT(" "); \
    Bus* bus__ = &findBus(\
        machine__, std::string("bus") + Conversion::toString(moveCounter__));\
    std::shared_ptr<Move> tempMove = nullptr;                                          \
    CONSTRUCT_MOVE;\
    tempInstruction__->addMove(tempMove);\
} moveCounter__++;

◆ NOP

#define NOP PRINTOUT("nop "); moveCounter__++;

A no-operation move.

Just skips the move slot by incrementing the move counter.

Definition at line 465 of file POMGenMacros.hh.

◆ OPERAND

#define OPERAND	(	OPERATION,
		OPERAND_INDEX
	)	OPORT(OPERATION, OPERAND_INDEX, OPERATION)

A shortcut to an operand in sequential code.

Parameters

OPERATION	The name of the operation.
OPERAND_INDEX	Index of the operand.

Definition at line 241 of file POMGenMacros.hh.

◆ OPORT

#define OPORT	(	FUNAME,
		PORTNAME,
		OPERATION
	)

Value:

    createTerminalFUPort( \
        machine__, #FUNAME, #PORTNAME, #OPERATION);\
    PRINTOUT(#FUNAME "." #OPERATION "." #PORTNAME)

Creates a TerminalFUPort using the given name strings.

Parameters

FUNAME	The function unit or operation name (in sequential).
PORTNAME	The port name or operand index (in sequential).
OPERATION	The name of the operation.

Definition at line 229 of file POMGenMacros.hh.

◆ PORT

#define PORT	(	FUNAME,
		PORTNAME
	)

Value:

    new TerminalFUPort( \
          dynamic_cast<BaseFUPort&>( \
              findFUPort(machine__, #FUNAME, #PORTNAME)));\
    PRINTOUT(#FUNAME "." #PORTNAME)

Creates a TerminalFUPort using the given name strings.

Parameters

FUNAME	The function unit or operation name (in sequential).
PORTNAME	The port name or operand index (in sequential).

Definition at line 216 of file POMGenMacros.hh.

◆ PRINTOUT

#define PRINTOUT ( STUFF )

define this to get the programs printed to stdout while they are contructed

Definition at line 73 of file POMGenMacros.hh.

◆ RA

#define RA ( )

Value:

   new TerminalFUPort(\
        dynamic_cast<BaseFUPort&>( \
            *machine__.controlUnit()->returnAddressPort()));\
    PRINTOUT("ra")

Creates a terminal pointing to the return address port of the GCU.

Definition at line 393 of file POMGenMacros.hh.

◆ REG

#define REG	(	RFNAME,
		REGNUM
	)

Value:

    new TerminalRegister(\
            *findRegisterFile(machine__, #RFNAME).port(0), \
            REGNUM);\
    PRINTOUT(#RFNAME "" #REGNUM)

Creates a TerminalRegister using the given register file and register.

Parameters

RFNAME	The register file name (either 'r' or 'f' in sequential).
REGNUM	The index of the register.

Definition at line 123 of file POMGenMacros.hh.

◆ SET_IP

#define SET_IP ( VALUE ) currentIP__ = VALUE

Forces a new value to the instruction pointer.

Parameters

VALUE The new value to assign to the instruction pointer counter.

Definition at line 495 of file POMGenMacros.hh.

◆ SET_IP_INCREMENT

#define SET_IP_INCREMENT ( COUNT ) incrementOfIP__ = COUNT

Sets the amount how much instruction pointer should be incremented after adding an instruction.

Parameters

COUNT The increment.

Definition at line 503 of file POMGenMacros.hh.

◆ SET_LABEL

#define SET_LABEL ( LABEL_NAME )

Value:

    PRINTOUT(#LABEL_NAME ":\n");\
    unsigned int LABEL(LABEL_NAME) = currentIP__; \
    LABEL(LABEL_NAME) = currentIP__;

Sets a label at the current instruction pointer position.

Using LABEL and SET_LABEL macros one can make implementing backward jumps easier.

Parameters

LABEL_NAME The name of the label to refer to.

Definition at line 485 of file POMGenMacros.hh.

                          :\n");\
    unsigned int LABEL(LABEL_NAME) = currentIP__; \
    LABEL(LABEL_NAME) = currentIP__;

Function Documentation

◆ createTerminalFUPort()

TTAProgram::TerminalFUPort * createTerminalFUPort	(	const TTAMachine::Machine &	machine,
		std::string	fuName,
		std::string	pName,
		std::string	opName
	)

Creates terminal of given parameters.

Definition at line 161 of file POMGenMacros.hh.

                                                         {
    
    TTAMachine::FunctionUnit& fu = findFunctionUnit(machine, fuName);        
    TTAMachine::HWOperation *op = NULL;
    
    if (fu.hasOperation(opName)) {
        op = fu.operation(opName);
    } else {
        op = new TTAMachine::HWOperation(opName, fu);
    }
    
    int index = 0;
     
    try {
        index = Conversion::toInt(pName);        
    } catch ( ... ) {
        index = op->io(*fu.operationPort(pName));
    }
 
    return new TTAProgram::TerminalFUPort(*op, index);
}

References findFunctionUnit(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::HWOperation::io(), machine, TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationPort(), and Conversion::toInt().

Here is the call graph for this function:

◆ findBooleanGuard()

TTAMachine::Guard & findBooleanGuard	(	const TTAMachine::Machine &	machine,
		bool	isInverted
	)

Helper function which finds either normal or inverted guard pointing to boolean register

Aborts with error if the boolean register file is not found.

Parameters

machine	The machine to search in.
isInverted	Do we look for inverted guard.

Returns: The found Guard

Definition at line 343 of file POMGenMacros.hh.

                                                                    {
 
    TTAMachine::Bus *bus = machine.busNavigator().item(0);
    
    // go through all the register files in the machine
    for (int i = 0; i < bus->guardCount(); ++i) {
    TTAMachine::RegisterGuard *regGuard = 
        dynamic_cast<TTAMachine::RegisterGuard*>(bus->guard(i));
    
    if (regGuard == NULL) {
        continue;
    }
    
    if (regGuard->isInverted() == isInverted &&       
        regGuard->registerFile()->width() == 1 && 
        regGuard->registerFile()->numberOfRegisters() == 1) {
        return *regGuard;
    }
    }
 
    // just to avoid compiler warnings
    abortWithError("Can't find BooleanGuard!");
    throw 1;
}

References abortWithError, TTAMachine::Machine::busNavigator(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::isInverted(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::RegisterGuard::registerFile(), and TTAMachine::BaseRegisterFile::width().

Here is the call graph for this function:

◆ findBooleanRegisterFile()

TTAMachine::RegisterFile & findBooleanRegisterFile ( const TTAMachine::Machine & machine )

Helper function which finds the boolean register file in the machine.

Aborts with error if the boolean register file is not found.

Parameters

machine The machine to search in.

Returns: The found register file.

Definition at line 312 of file POMGenMacros.hh.

                                                          {
    
    TTAMachine::Machine::RegisterFileNavigator navigator = 
        machine.registerFileNavigator();
    
    // go through all the register files in the machine
    for (int i = 0; i < navigator.count(); ++i) {
        TTAMachine::RegisterFile& rf = *navigator.item(i);
        
        // expect the boolean register to be the first register file with
        // only one register of width 1
        if (rf.width() == 1 && rf.numberOfRegisters() == 1) {
            return rf;
        }
    }
    // just to avoid compiler warnings
    abortWithError("Can't find boolean register file from machine!.");
    throw 1;
}

References abortWithError, TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Machine::registerFileNavigator(), and TTAMachine::BaseRegisterFile::width().

Here is the call graph for this function:

◆ findBus()

TTAMachine::Bus & findBus	(	const TTAMachine::Machine &	machine,
		std::string	busName
	)

Helper function which finds a bus in a machine.

Aborts with error if the bus is not found.

Parameters

machine	The machine to search in.
busName	The name of the bus. Unused in case of UniversalMachine.

Returns: The found bus.

Definition at line 269 of file POMGenMacros.hh.

                                                             {
    if (dynamic_cast<const UniversalMachine*>(&machine) != NULL) {
        return dynamic_cast<const UniversalMachine&>(machine).universalBus();
    } else {
        TTAMachine::Machine::BusNavigator nav = machine.busNavigator();
        return *nav.item(busName);
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and machine.

Here is the call graph for this function:

◆ findFunctionUnit()

TTAMachine::FunctionUnit & findFunctionUnit	(	const TTAMachine::Machine &	machine,
		std::string	name
	)

Helper function which finds a function unit in the machine.

Aborts with error if the function unit is not found.

Parameters

machine	The machine to search in.
name	The name of the function unit. Can be empty in sequential.

Returns: The found register file.

Definition at line 146 of file POMGenMacros.hh.

                                                                   {
    if (dynamic_cast<const UniversalMachine*>(&machine) != NULL) {
        return dynamic_cast<const UniversalMachine&>(
            machine).universalFunctionUnit();
    } else {
        TTAMachine::Machine::FunctionUnitNavigator nav = 
            machine.functionUnitNavigator();
        return *nav.item(name);
    }
}

References TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and machine.

Referenced by createTerminalFUPort(), and findFUPort().

Here is the call graph for this function:

◆ findFUPort()

TTAMachine::Port & findFUPort	(	const TTAMachine::Machine &	machine,
		std::string	fuName,
		std::string	portName
	)

Helper function which finds a port in a function unit.

Aborts with error if the port is not found.

Parameters

machine	The machine to search in.
fuName	The name of the function unit. The operation, if sequential.
portName	The name of the port. The operand, if sequential code.

Returns: The found port.

Definition at line 196 of file POMGenMacros.hh.

                        {
    
    if (dynamic_cast<const UniversalMachine*>(&machine) != NULL) {
        return *dynamic_cast<const UniversalMachine&>(machine).
            universalFunctionUnit().operation(fuName)->port(
                Conversion::toInt(portName));
    } else {
        return *findFunctionUnit(machine, fuName).port(portName);
    }
}

References findFunctionUnit(), machine, TTAMachine::FunctionUnit::port(), and Conversion::toInt().

Here is the call graph for this function:

◆ findRegisterFile()

TTAMachine::RegisterFile & findRegisterFile	(	const TTAMachine::Machine &	machine,
		std::string	name
	)

Helper function which finds a register file in the machine.

Aborts with error if the register file is not found.

Parameters

machine	The machine to search in.
name	The name of the register file.

Returns: The found register file.

Definition at line 94 of file POMGenMacros.hh.

                                                                   {
 
    if (dynamic_cast<const UniversalMachine*>(&machine) != NULL) {
    if (StringTools::ciEqual(name, "r")) {
        return dynamic_cast<const UniversalMachine&>(
        machine).integerRegisterFile();
    } else 
        if (StringTools::ciEqual(name, "f")) {
        return dynamic_cast<const UniversalMachine&>(
            machine).doubleRegisterFile();
        }
    abortWithError(std::string("No register file ") + name + " found.");
    } else {
        TTAMachine::Machine::RegisterFileNavigator nav = 
            machine.registerFileNavigator();
    return *nav.item(name);
    }
 
    abortWithError("Can't find register file " + name);
    // just to avoid compiler warnings    
    throw 1;
}

References abortWithError, StringTools::ciEqual(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine, and TTAMachine::Machine::registerFileNavigator().

Here is the call graph for this function:

◆ null__()

void null__ ( )

A procedure that does nothing.

Definition at line 81 of file POMGenMacros.hh.

81 {

82}

◆ tempSimValue()

SimValue & tempSimValue	(	unsigned int	bitWidth,
		SIntWord	intValue
	)

Creates a temporary SimValue to be used in TerminalImmediate construction.

Parameters

bitWidth	The bit width of the SimValue.
intValue	The integer value of the SimValue.

Returns: A SimValue reference (owned by the function).

Definition at line 252 of file POMGenMacros.hh.

                                                       {
    delete temporary;
    temporary = new SimValue(bitWidth);
    *temporary = intValue;
    return *temporary;
}

References temporary.

Variable Documentation

◆ temporary

SimValue* temporary = NULL

Definition at line 76 of file POMGenMacros.hh.

Referenced by EnableBPCommand::execute(), and tempSimValue().

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ BASIC_MOVE_CONSTRUCTION

◆ BOOL

◆ BOOLGUARD

◆ CONTROL_OPERAND

◆ CREATE_PROCEDURE

◆ CREATE_PROGRAM

◆ END_PROGRAM

◆ GMOVE

◆ GUARDED_MOVE_CONSTRUCTION

◆ IMM

◆ IMM32

◆ INSTRUCTION

◆ INVBOOLGUARD

◆ IREG

◆ LABEL

◆ MOVE

◆ MOVE_TEMPLATE

◆ NOP

◆ OPERAND

◆ OPORT

◆ PORT

◆ PRINTOUT

◆ RA

◆ REG

◆ SET_IP

◆ SET_IP_INCREMENT

◆ SET_LABEL

Function Documentation

◆ createTerminalFUPort()

◆ findBooleanGuard()

◆ findBooleanRegisterFile()

◆ findBus()

◆ findFunctionUnit()

◆ findFUPort()

◆ findRegisterFile()

◆ null__()

◆ tempSimValue()

Variable Documentation

◆ temporary